-
结构体struct类似python语言中的类class,结构体类的元素可以是一个变量，或者函数或者其它的类型，好比python的属性和方法。
// struct结构体，类似python语言中的class类
package main
import "fmt"
type person struct { //定义一个strcut
Name string
Age int
} func main() {
a := person{} //赋值给一个变量a
fmt.Println(a)
a.Name = "faily" //为结构体赋值
a.Age = 28
fmt.Println(a)
}
/*输出结果
{ 0} //空结构体时，int元素为0
{faily 28}
*/ -
简单的方式进行结构体的初始化
package main
import "fmt" type person struct { //定义一个strcut
Name string
Age int
}
func main() {
a := person{ //也可以这样初始化一个结构体
Name: "msy",
Age: 27,
}
fmt.Println(a)
} -
struct也是一个
值类型,也就是说传递的时候，拷贝的是值,正常途径无法改变结构内的值，需通过指针的方式进行修改package main
import "fmt" type person struct { //定义一个strcut
Name string
Age int
} func main() {
a := person{ //初始化结构体
Name: "msy",
Age: 27,
}
fmt.Println("1", a)
A(a)
fmt.Println("3", a)
B(&a) //指针引用
fmt.Println("4", a) } func A(per person) { // 参数引用person--结构体
per.Age = 13 //初始化person属性的值
fmt.Println("2", per)
} func B(per *person){ //传递指针
per.Age =13
fmt.Println("2",per)
}
/*输出
初始化： 1 {msy 27}
修改A： 2 {msy 13}
修改失败： 3'{msy 27}
修改B： 2 {msy 13}
修改成功： 3"{msy 13}
*/ -
推荐结构体初始化时，使用结构体指针，修改的时候更加方便
package main
import "fmt" type person struct { //定义一个strcut
Name string
Age int
} func main() {
a := &person{ //初始化结构体,建议使用结构的指针
Name: "msy",
Age: 27,
}
a.Name = "MYF" //这种方式就可以直接修改结构体
fmt.Println("1", a)
A(a) //此时就可以直接修改结构体
B(a)
fmt.Println("3", a)
} func A(per *person) { //传递指针
per.Age = 13 //初始化person属性的值
fmt.Println("2", per)
} func B(per *person) { //传递指针
per.Age = 100
fmt.Println("2", per)
} /*输出
1 &{MYF 27}
2 &{MYF 13}
2 &{MYF 100}
3 &{MYF 100}
*/ -
匿名结构:没有名字的结构
package main
import "fmt" func main() {
a := &struct { //指向结构体指针
Name string
Age int
}{ //直接初始化
Name: "moshaoying",
Age: 27,
}
fmt。Println(a)
} /*输出
&{moshaoying 27}
*/ -
嵌套匿名结构体，初始化方式
package main
import "fmt" type person struct { //嵌套匿名结构
Name string
Age int
Content struct {
Phone int
Addr string
}
} func main() {
a := person{Name: "moshaoying", Age: 22}
a.Content.Phone = 13636269334 //嵌套匿名结构体初始化方式
a.Content.Addr = "shanxi,xian" fmt.Println(a)
} /*输出
{moshaoying 22 {13636269334 shanxi,xian}}
*/ -
结构体比较： 命名是结构体的一部分，所以只有当结构体命名相同时才可以进行比较
package main
import "fmt" type person struct { //嵌套匿名结构
Name string
Age int
} type person1 struct {
Name string
Age int
} func main() {
a := person{Name: "moshaoying", Age: 22}
b := person1{Name: "moshaoying", Age: 22}
c := person{Name: "moshaoying", Age: 22}
d : = person{Name: "moshaoying", Age: 21}
fmt.Println(a == b)
fmt.Println(a == c)
fmt.Println(a == d)
} /*输出报错
a=b invalid operation: a == b (mismatched types person and person1)
a=c true
a=d false
*/ -
结构体没有python类的继承，但是结构体也会有类似的功能，结构体嵌套，达到继承其它结构体的属性
package main
import "fmt" type human struct {
Sex int
}
type person struct { //结构体继承(嵌套)
human
Name string
Age int
} func main() {
a := person{Name: "failymao", Age: 22, human: human{Sex: 250}} //第一种方式，注意原理
fmt.Println(a)
//第二种方式
a.Name = "allen"
a.Age = 29
a.Sex = 222
fmt.Println(a)
} /*输出报错
第一种方式： {{250} failymao 22}
第二种方式： {{222} allen 29}
*/