指针

1.&和*

在go语言中，也有指针的概念，不同于java。是没有指针的概念的。但是go语言的指针也并没有c中的复杂。

首先需要了解的是指针相关的两个符号 & 和 * 这两种符号。
& 代表了地址操作符，表示的是取到的一个变量或者结构的内存地址
* 代表解地址操作，对于&类型的的变量取出它们值，如果放在类型前面则表示是指针类型。

func main() {
    a := "a"
    fmt.Println(&a)//0xc0000501f0

    b := &a
    fmt.Println(*b)//a
}

当用*表示指针类型时，传入的值需要是一个内存地址的值，也就是传入的值是使用&表示或者隐式指针。
如果改变内存地址上的值，那么所有指向该地址的值都将被修改。

func main() {
    //定义一个string的指针类型，然后通过取地址b赋值给a，通过解引用打印出a
    var a *string
    b := "a"
    a = &b
    fmt.Println(*a)//a

    //这个时候如果修改b的值那么*a的值也将会改变，因为a存储的是b的地址值
    //所以当b的值改变时，a通过该地址解析出的值也会是b改变了的值
    b ="b"
    fmt.Println(*a)//b

    //当然*a表示的也是a指向的内存地址上的值，所以改变*a的值也相当于改变了所有指向a地址的值。
    //因为最开始将b的地址赋值给了a，所以*a改变时，b的值也发生了改变
    *a = "c"
    fmt.Println(b)//c
}

上面例子中a可以理解为是一个普通的变量，如果将a赋值给其它变量，那和普通变量赋值没什么区别，对于系统来说是把a地址上的值拷贝了一份给另一个变量。

2.结构和数组的指针

对于结构和数组，go语言提供了一些人性化的操作，自动解引用。

func main() {
    type skill struct{
        time int
    }

    type people struct {
        name string
        age  int32
        skill
    }

    var zhangshan = &people{name: "张三"}

    //两种方式都是相同的结果，因为go语言帮我们自动解引用了，所以我们可以去除多余的括号和*
    fmt.Println((*zhangshan).name)
    fmt.Println(zhangshan.name)
    
    //但是如果你要改变该地址的值，相当于在这个地址，重新new一个people，那么*号必不可少
    *zhangshan = people{name: "李四"}
    
    //数组也会自动解引用
    num := &[8]int{0,1,2,3,4,5,6,7}

    fmt.Println(num[1])
    fmt.Println(num[1:4])
}

3.将指针作为参数或方法的接收者、内部指针

使用指针传递可以起到改变值的作用。

func main() {
    one := people{
        name: "张三",
        age: 17,
        skill:skill{
            time: 10,
        },
    }
    fmt.Println(one.age)//17
    agePlusMistaken(one)//数据只是拷贝了一份过去
    fmt.Println(one.age)//17

    agePlus(&one)

    fmt.Println(one.age)//18

    //同理，使用指针类型的作为接收者时，也会起到改变值的效果
    one.agePlus()
    fmt.Println(one.age)//19

    //对于嵌套结构来说，go语言提供了内部指针这种方式，为我们轻松确定结构中指定字段的内存地址
    fmt.Println(one.time)//10
    timePlus(&one.skill)
    fmt.Println(one.time)//11
}

type people struct {
    name string
    age  int32
    skill
}

func (p *people) agePlus(){
    p.age++
}

func agePlus(p *people){
    p.age++
}

func agePlusMistaken(p people){
    p.age++
}

type skill struct{
    time int
}

func timePlus(s *skill){
    s.time++
}

并且大家应该注意到，上面的代码在one并不是一个内存地址类型。但是对于结构体来说，他可以自动传入的引用或非引用参数，而不需要加&号。
但是对于内部嵌套数据的地址，则必须得通过&来进行调用

4.隐式指针

对于map来说，它本身就是一种指针，所以在传递的时候默认就是以指针形式传递，对它的修改也会导致它原本的数据被修改。（文章4说map的时候有提到过）
切片也是通过指针来设置他在一个数组里面的长度、容量和位置的。

5.指针和接口

接口也可以使用指针类型的接收者。
但是当接收者为非指针时，无论传递指针和非指针形式，对传递的值都不会有影响，也都可以正常调用。
但是当接收者为指针类型时，只能传递指针类型的变量，并且在接口内部修改值会对外部值产生影响。

func main() {
    p := people{
        name: "张三",
        age: 10,
    }
    hello(p)
    fmt.Println(p.age)//10
    hello(&p)
    fmt.Println(p.age)//10

    p2 := people2{
        name: "张三",
        age: 10,
    }
    //hello(p2)  当变为指针时，只能传递指针类型
    fmt.Println(p2.age)//10
    hello(&p2)
    fmt.Println(p2.age)//11
}

type speaker interface {
    speak() string
}

type people struct {
    name string
    age  int32
}

func (p people) speak() string {
    p.age++
    return p.name + " 说你好呀！"
}

type people2 struct {
    name string
    age  int32
}

func (p *people2) speak() string {
    p.age++
    return p.name + " 说你好呀！"
}

func hello(t speaker) {
    fmt.Println(t.speak())
}

Go语言入门总结（六）-指针