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