结构体

Go语言没有纯粹的面向对象概念，都是使用结构体、函数等来实现。面相对象编程的一些特性，例如：继承、组合等特性

定义

主要是struct关键字，结构如下：

type struct_name struct{
	member defintion
}
1
2
3

type：结构体定义关键字

struct_name：结构体类型名称

struct：结构体定义关键字

member definition：成员定义

结构体的初始化

未初始化时，成员都是零值，int—>0，float—>0，bool—>false，string—>nil

type test struct {
   name bool
   id   float32
   sex  string
   age  int
}
var Sentiment test
fmt.Println(Sentiment)
1
2
3
4
5
6
7
8

结果：

{false 0  0}
1

结构体成员声明与赋值

点运算符赋值

Demo01

package main

import "fmt"

func main() {
   type test struct {
      name string
      id   int
      sex  string
      age  int
   }
   var Sentiment test				//声明
   Sentiment.id = 1					//下面都属于点运算符赋值部分
   Sentiment.name = "Sentiment"
   Sentiment.sex = "man"
   Sentiment.age = 18
   fmt.Println(Sentiment)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

结果:

{Sentiment 1 man 18}
1

键值对赋值

除此之外还可以通过键值对赋值

package main

import "fmt"

func main() {
   type test struct {
      name string
      id   int
      sex  string
      age  int
   }
   Sentiment := test{
      name: "Sentiment",
      id:   1,
      sex:  "man",
      age:  18,        //注：最后也需要加逗号
   }

   fmt.Println(Sentiment)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

匿名结构体

如果结构体是临时使用，可以不用起名字，直接使用

demo02

package main

import "fmt"

func main() {
   var dog struct {
      id   int
      name string
   }
   dog.id = 1
   dog.name = "Tana"
   fmt.Println(dog)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

结果：

{1 Tana}
1

结构体指针

demo03

结构体指针和普通的变量指针类似

package main

import "fmt"

func main() {
   type Person struct {
      id   int
      name string
   }
   var Sentiment = Person{1, "Sentiment"}
   var p_person = &Sentiment
   fmt.Printf("Sentiment:%v\n", Sentiment)		//输出结构体
   fmt.Printf("p_person:%p\n", p_person)		//结构体地址
   fmt.Printf("p_person:%v", p_person)			//结构体地址对应的值

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

结果：

Sentiment:{1 Sentiment}
p_person:0xc000004078
p_person:&{1 Sentiment}
1
2
3

new关键字创建结构体指针

除了上述的&赋值创建外，可以通过new关键字对结构体进行实例化，得到的是结构体的地址

package main

import "fmt"

func main() {
   type Person struct {
      id   int
      name string
   }
   var p_person = new(Person)

   fmt.Printf("p_person:%T\n", p_person)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果：

p_person:*main.Person
1

结构体指针成员赋值

结构体指针成员，也可以用点运算符进行赋值

package main

import "fmt"

func main() {
   type Person struct {
      id   int
      name string
   }
   var p_person = new(Person)
   p_person.id = 1
   p_person.name = "Sentiment"
   fmt.Printf("p_person:%v", p_person)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果：

p_person:&{1 Sentiment}
1

结构体作为函数参数

结构体也可以像变量一样，作为函数的实参传递给函数，分为两种方式：

• 直接传递结构体：在函数内部不会改变外部结构体的内容(相当于一次调用结构体的值本身不会发生改变)
• 传递结构体指针：在函数内部，能够改变外部结构体的内容(由于使用的是指针，所以是对内存地址进行的操作，结构体发生改变)

直接传递结构体

Demo04

package main

import "fmt"

type Person struct {
   name string
   id   int
}

func show(person Person) {
   person.id = 1
   person.name = "Sentiment"
   fmt.Println(person)
}
func main() {
   person := Person{"Tana", 2}
   fmt.Printf("person: %v\n", person)			
   fmt.Println("-------------")
   show(person)								//调用show方法后值发生改变
   fmt.Println("-------------")
   fmt.Printf("person: %v", person)			//但只是进行了一次调用，再次输出person的值，还是不变的
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结果：

person: {Tana 2}
-------------
{Sentiment 1}
-------------
person: {Tana 2}
1
2
3
4
5

传递结构体指针

package main

import "fmt"

type Person struct {
	name string
	id   int
}

//func show(person Person) {
//	person.id = 1
//	person.name = "Sentiment"
//	fmt.Println(person)
//}
func show2(person *Person) {
	person.id = 3
	person.name = "Mumu"
	fmt.Println(person)
}
func main() {
	person := Person{"Tana", 2}
	fmt.Printf("person: %v\n", person)
	fmt.Println("-------------")
	show2(&person) 								//调用show2方法，获取的形参是指针类型
	fmt.Println("-------------")
	fmt.Printf("person:%v", person) 		//由于是指针类型，取的内存地址，因此调用后外部的结构体值也发生改变
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

结果：

person: {Tana 2}
-------------
&{Mumu 3}
-------------
person:{Mumu 3}
1
2
3
4
5

结构体的嵌套

假设一个人Person结构体，这个人还养了一直宠物Dog结构体

Dog结构体

type Dog struct {
   name string
   age  int
}
1
2
3
4

Person1结构体

type Person1 struct {
	dog  Dog
	name string
	id   int
}
1
2
3
4
5

Demo05

package main

import "fmt"

type Dog struct {
   name string
   age  int
}
type Person1 struct {
   dog  Dog
   name string
   id   int
}

func main() {
   Sentiment := new(Person1)
   Sentiment.id = 1
   Sentiment.name = "Sentiment"
   Sentiment.dog.name = "Tana"
   Sentiment.dog.age = 3
   fmt.Println(Sentiment)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结果：

&{{Tana 3} Sentiment 1}
1