struct

package main

import (
    "fmt"
)

type test struct{} //空的结构体

type person struct {
    name string
    age  int
}

type student struct { //结构体嵌套
    name    string
    age     int
    contact struct {
        phone, city string
        num         int
    }
}

type teacher struct { //匿名字段
    string
    int
}

func main() {
    a := test{}
    fmt.Println(a) //{}

    p := person{}
    fmt.Println(p) //{ 0}
    p.name = "joi"
    p.age = 19
    fmt.Println(p)      //{joi 19}
    fmt.Println(p.name) //joi

    p1 := person{
        name: "lll",
        age:  32,
    }
    fmt.Println(p1)      //    {lll 32}
    fmt.Println(p1.name) //lll

    A(p1)
    fmt.Println(p1.age) //32,值拷贝，不是引用传递

    A1(&p1)
    fmt.Println(p1.age) //888，指针传递，

    p2 := &person{ //p2就是指向结构体的地址了，以后和传递就是指针传递了，
        name: "kkk",
        age:  1,
    }

    A1(p2)
    p2.name = "OK"       //p2是一个地址，这里不需要用*p2 = "OK"
    fmt.Println(p2.name) //OK，

    b := struct { //匿名结构体
        name string
        age  int
    }{
        name: "uuu",
        age:  19,
    }
    fmt.Println(b) //{uuu 19}

    //匿名结构体
    c := &struct {
        name string
        age  int
    }{
        name: "eee",
        age:  29,
    }
    fmt.Println(c) //&{eee 29}

    d := student{}
    fmt.Println(d) //{ 0 {  0}}
    d = student{
        name: "dd",
        age:  1,
    }
    d.contact.city = "sity"
    d.contact.num = 9
    d.contact.phone = "phone" //里面的结构体只能够分部赋值
    fmt.Println(d)            //{dd 1 {phone sity 9}}

    e := teacher{"tec", 52} //依靠顺序传值
    fmt.Println(e)          //{tec 52}
    var e1 teacher
    e1 = e
    fmt.Println(e1) //{tec 52},结构体可以直接赋值
}

func A(per person) {
    per.age = 999
    fmt.Println(per.age) //999
}

func A1(per *person) {
    per.age = 888
    fmt.Println(per.age) //888
}

package main

/*
结构struct

Go 中的struct与C中的struct非常相似，并且Go没有class，
struct代替了class的位置但是没有代替class的功能，因为go没有继承的概念
使用 type <Name> struct{} 定义结构，名称遵循可见性规则
支持指向自身的指针类型成员
支持匿名结构，可用作成员或定义成员变量
匿名结构也可以用于map的值
可以使用字面值对结构进行初始化
允许直接通过指针来读写结构成员
相同类型的成员可进行直接拷贝赋值
支持 == 与 !=比较运算符，但不支持 > 或 <
支持匿名字段，本质上是定义了以某个类型名为名称的字段
嵌入结构作为匿名字段看起来像继承，但不是继承
可以使用匿名字段指针

*/

import (
    "fmt"
)

//实现继承,嵌入结构（组合）
type human struct {
    sex int
}

type teacher struct {
    human
    name string
    age  int
}

type student struct {
    human
    name string
    age  int
}

func main() {
    a := teacher{name: "teac", age: 32}
    b := student{name: "stud", age: 18}
    fmt.Println(a, b) //{{0} teac 32} {{0} stud 18}

    a1 := teacher{name: "teac", age: 32, human: human{sex: 1}}
    b1 := student{name: "stud", age: 18, human: human{sex: 1}}
    fmt.Println(a1, b1) //{{1} teac 32} {{1} stud 18}
    a1.age = 88
    a1.human.sex = 100  //a1.sex = 200也可以，因为human的字段就已经是teacher和student的属性了，
    fmt.Println(a1, b1) //{{100} teac 88} {{1} stud 18}
}