【Golang系列】-结构体指针

2022-03-17

结构体指针

结构体指针和普通变量指针相同，先回顾一下普通变量指针：

package main

import "fmt"

func main() {
    var name string
    name = "caolihui"

    var p_name *string //指针类型
    p_name = &name //取name地址

    fmt.Println(name)
    fmt.Println(p_name) //输出指针地址
    fmt.Println(*p_name) //输出指针指向指向内容值
}

go结构体指针

package main

import "fmt"

func main() {
    type Person struct {
        id   int
        name string
    }
    caolihui := Person{
        id:   1,
        name: "caolihui",
    }

    var p_persion *Person
    p_persion = &caolihui

    fmt.Println(caolihui)
    fmt.Println(p_persion)
    fmt.Println(*p_persion)
}

使用new挂件自创建结构体指针
我们还可以通过使用new关键字对结构体进行实例化，得到的式结构体的地址

package main

import "fmt"

func main() {
    type Person struct {
        id   int
        name string
    }
    
    var p_persion = new(Person)
    fmt.Println(p_persion)

}

访问结构体指针成员

package main

import "fmt"

func main() {
    type Person struct {
        id   int
        name string
    }

    var p_persion = new(Person)

    fmt.Println(p_persion)

    p_persion.id = 1
    p_persion.name = "caolihui"

    fmt.Println(*p_persion)

}

结构体作为函数参数

go结构体可以和普通变量 一样，作为函数传参，传递给函数，分两种情况
直接传递结构体，这是一个拷贝，在函数内部不会改变外面结构体的内容
传递结构体指针，这时在函数内部，能够改变外部结构体内容

直接传递结构体

package main

import "fmt"

type Person struct {
    id   int
    name string
}

func showPerson(person Person) {
    person.id = 1
    person.name = "caolihui"
    fmt.Println(person)
}

func main() {
    person := Person{1, "tom"}
    fmt.Println(person)
    fmt.Println("------------")

    showPerson(person)
    fmt.Println("-----------")

    fmt.Println(person)
}

结果：

{1 tom}
------------
{1 caolihui}
-----------
{1 tom}

从运行结果看的话，函数内部改变了结构体内容，函数外并没有被改变

传递结构体指针

package main

import "fmt"

type Person struct {
    id   int
    name string
}

func showPerson(person *Person) {
    person.id = 1
    person.name = "caolihui"
    fmt.Println(person)
}

func main() {
    person := Person{1, "tom"}
    fmt.Println(person)
    fmt.Println("------------")

    showPerson(&person)
    fmt.Println("-----------")

    fmt.Println(person)
}

结果：

{1 tom}
------------
&{1 caolihui}
-----------
{1 caolihui}

从结果看，调用函数后，参数被改变了

嵌套结构体：

go中没有面向对象思想，也没有继承关系，但是可以通过结构体嵌套来实现这种效果

Dog结构体

type Dog struct{
    name string
    color string
    age int
}

Person结构体
type person struct{
    dog Dog
    name string
    age int
}

访问

package main

import (
    "fmt"
)

type Dog struct {
    name  string
    color string
    age   int
}

type person struct {
    dog  Dog
    name string
    age  int
}

func main() {
    var tom person
    tom.dog.name = "小花"
    tom.dog.age = 2
    tom.dog.color = "花色"

    tom.name = "tom"
    tom.age = 30

    fmt.Println(tom)
}

结果：

{{小花 花色 2} tom 30}