golang结构体和方法

一.结构体

1.1结构体定义

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
go语言没有类(class)的概念,只有结构体(struct)

// 使用type和struct来定义一个结构体
type Person struct {
	name string
	age int
	Email string
}

1.2成员变量

1.2.1 访问控制机制
如果一个结构体成员变量名称首字母大写:public 在其他包可以访问
首字母小写:private

type A struct {
    Hour int    //可导出
    minute int  //不可导出
}

1.1.2 限制
结构体不可以包含自己

type B struct {
	value int
	//Next B   //错误
	Next *B    //正确
}

1.3 结构体初始化

//定义一个结构
type Node struct {
	Value       int
	Left, Right *Node
}

func main() {
	var root Node
	//初始化为零值
	//{0 <nil> <nil>}
	//fmt.Println(root)
	root = Node{Value: 3}
	
	//{3 <nil> <nil>}
	root.Left = &Node{}
	
	//{3 0xc000088080 <nil>}
	root.Right = &Node{5, nil, nil}
	
	//{3 0xc0000564a0 0xc0000564e0}
	//new 是一个用来分配内存的内置函数
	//但是与 C++ 不一样的是，它并不初始化内存，只是将其置零。
	//也就是说，new(T) 会为类型 T 分配被置零的内存，并且返回它的地址，一个类型为 *T 的值
	//在 Golang 的术语中，其返回一个指向新分配的类型为 T 的指针，这个指针指向的内容的值为零(zero value)。
	//new(Type) 和 &Type{} 是等价的
	root.Right.Left = new(tNode)
	root.Left.Right = &Node{Value: 2}

}

1.4结构体比较

1.4.1 如果结构体的所有成员变量都可以比较,那么这个结构体是可以比较的.

type C struct {
    A int
    B string
}
c1 := C{A:1, B:"abc"}
c2 := C{A:1, B:"abc"}
c3 := C{A:2, B:"abc"}
fmt.Println(c1.A == c2.A && c1.B == c2.B) //true
fmt.Println(c1 == c2)                        //true 与上等价
fmt.Println(c1.A == c3.A && c1.B == c3.B) //false
fmt.Println(c1 == c3)                        //false 与上等价

1.4.2 和其他可比较的类型一样，可比较的结构体类型都可以作为map的键类型

type C struct {
    A int
    B string
}
mp := make(map[C]int)
key := C{A:1, B:"abc"}
mp[key] = 9
fmt.Println(mp[C{A:1, B:"abc"}])  //9

1.5.结构体嵌套和匿名成员

1.5.1 定义指定类型不带名称的结构体成员称为匿名成员

type Person struct {
    name string
    age int
    int // 匿名字段
}

1.5.2 内嵌结构体

func main() {
	type Person struct {
		Name  string
		Age     int
		Email string
	}
	type Student struct {
		Person
		StudentID int
	}
	st := Student {
		Person:    Person{"Cocktail_py", 22, "[email protected]"},
		StudentID: 1000,
	}
	//{{Cocktail_py 22 [email protected]} 1000}
	fmt.Println(st)
}

二.方法

2.1给结构体定义方法的格式: (接收者) 函数名

func (node Node) Print() {
	fmt.Print(node.Value, " ")
}

//普通函数类型的定义方式
//func Print(node Node) ()  {
//	fmt.Print(node.value)
//}

//遍历函数 
//中序遍历:先左再中再右
func (node *Node) Traverse(){
	if node == nil {
		return
	}
	node.Left.Traverse()
	node.Print()
	node.Right.Traverse()
}

2.2结构体为值类型,通过指针改变值

//值传递
func (node *Node) SetValue(value int) {
	if node == nil {
		fmt.Println("Setting value to nil. Ignore")
		return
	}
	node.Value = value
}

2.3结构体的扩展

type myNode struct {
	node *Node
}

参考:https://www.jianshu.com/p/b6ae3f85c683
参考:https://www.cnblogs.com/sparkdev/p/10761825.html