结构体的定义只是一种内存布局的描述，只有当结构体实现实例化时，才会真正地分配内存，因此必须在定义结构体并实例化后才能使用结构体的字段。实例化就是根据结构体定义的格式创建一份与格式一致的内存区域，结构体实例与实例间的内存是完全独立的。
实例化方式包括如下几种。

1、实例化之 ：var 变量名 结构体

结构体本身是一种类型，它属于值类型，可以像整型、字符串等类型一样，以var的方式声明结构体即可完成实例化。

package main
import "fmt"
type Student struct {
   sid, age int
   name     string
   sex      byte
   score    [3]int
}
func main() {
   // 声明一个结构体对象，值类型，默认开辟空间，字段默认赋予零值
   var s Student
   fmt.Println(s) //{0 0  0 [0 0 0]}
   // 要访问结构体成员，需要使用点号 . 操作符
   fmt.Println(s.name) // ""
   // 更改成员变量
   s.name = "sgg"
   s.score[0] = 100
   fmt.Println(s.name) // "sgg"
   fmt.Println(s.score) // [100 0 0]
}

1. 结构体属于值类型，即var 声明后会像整型、字符串一样创建内存空间
2. 创建结构体对象，如果没有给字段赋值，则默认零值(字符串默认 “”,数值默认0，布尔默认false，切片和map默认nil对象)

结构体的内存存储：

package main
import "fmt"
type Student struct {
   name string
   age  int
}
func main() {
   var s1 Student
   fmt.Println(s1) // { 0}
   var s2 Student
   s2.name = "sgg"
   s2.age = 22
   fmt.Printf("%p\n", &s2)        // 0xc00009a018
   fmt.Printf("%p\n", &(s2.name)) // 0xc00009a018
   fmt.Printf("%p\n", &(s2.age))  // 0xc00009a028
}

之前我们学习过值类型和引用类型，知道值类型是变量对应的地址直接存储值，而引用类型是变量对应地址存储的是地址。因为结构体是值类型，所以对象s的地址与存储的第一个值的地址相同的，而后面每一个成员变量的地址是连续的。

2、实例化之 ：结构体{}

type Student struct {
   name string
   age  int
}
// 方式1
var s1 = Student{}
s1.name = "sgg"
// 方式2：键值赋值
var s2 = Student{name: "sgg", age: 22}
fmt.Println(s2.name) //sgg
fmt.Println(s2.age)    //22
// 方式3：多值赋值
var s3 = Student{"sgg",22}
fmt.Println(s3.name) //sgg
fmt.Println(s3.age)  //22

1. 结构体可以使用 “键值对” (key value pair) 初始化字段，每个”键”(Key)对应结构体中的一个字段，键的”值”(value)对应字段需要初始化的值。键值对的填充是可选的，不需要初始化的字段可以不填入初始化列表中。
2. 多值初始化必须初始化结构体的所有字段且每一个初始值的填充顺序必须与字段在结构体中的声明顺序一致。
3. 键值对与值列表的初始化形式不能混用。

3、实例化之 ：&结构体{}

package main
import "fmt"
type Student struct {
   name string
   age  int
}
func changeAge(stu *Student) {
   stu.age = 23
}
func main() {
   s1 := Student{name: "alvin", age: 22}
   s2 := s1 // 值copy，s2 跟 s1 不属于内存地址
   s1.name = "sgg"
   fmt.Println(s2.name) // alvin
   fmt.Println(s1.name) // sgg
   // 如果希望s3的值跟随s2保持一致怎么实现， 就需要用到地址
   s3 := &s1 // var s3 *Student = &s2
   fmt.Println(s3.name)
   // 取地址
   s := &Student{name: "sbh", age: 33}
   changeAge(s)
   fmt.Println((*s).age) // 23，*s.course的写法是错误的
   fmt.Println(s.age) // 23 => Go语言这边做了 语法糖 把 (*s).age 形式转成了s.age
}

在Go语言中，访问结构体指针的成员变量时，可以继续使用 . ，这是因为Go语言为了方便开发者访问结构体指针的成员变量可以像访问结构体的成员变量一样简单，使用了 语法糖(Syntactic sugar) 技术，将 instance.name 形式转换为 (*instance).name

4、实例化之： New(结构体)

Go语言中，还可以使用 new 关键字对类型(包括结构体、整型、浮点型、字符串等)进行实例化，结构体在实例化后会形成指针类型的结构体。使用new的格式如下：

instance := new(T)

其中：

• T 为类型，可以是结构体、整型、字符串等。
• instance： T 类型被实例化后保存到 instance 变量中，instance 的类型为 *T，属于指针。

package main
import (
   "fmt"
   "reflect"
)
type Student struct {
   name string
   age  int
}
func main() {
   s := new(Student)              // &Student{}
   fmt.Println(reflect.TypeOf(s)) // *Student
   s.name = "sgg"
   fmt.Println(s.name) // sgg
}

存放多个结构体对象：

package main
import "fmt"
type Student struct {
   name string
   age  int
   sex  byte
   addr string
}
func main() {
   s1 := new(Student)
   s2 := new(Student)
   s3 := new(Student)
   s4 := new(Student)
   s := []*Student{s1, s2, s3, s4}  // 存储多个指针类型的结构体对象
   fmt.Println(s)
}