1.指针

- 一个指针变量指向了一个值的内存地址
- 定义指针变量
- 为指针变量赋值：&
- 修改指针变量中多指向地址的值：*

func main() {
        var a int =10 //声明变量
        fmt.Printf("a内存地址:%p\n",&a)
        var p *int //声明指针
        p=&a //p存储a的内存地址
        fmt.Println("p存储的地址:",p)
        fmt.Println("p自己的内存地址:",&p)
        //修改a或者*p的值，所指向同一个地址的变量的值都会变化
        a =20
        fmt.Println("a的值",a)
        fmt.Println("p的值",*p)
        *p=30
        fmt.Println("a的值",a)
        fmt.Println("p的值",*p)
}

2.指针指向指针

- 格式：var p **int
- 一个指针变量存放的是另一个指针变量的地址
- 第一个指针变量存放第二个指针的地址，第二个指针存放变量的地址

func main() {
    var a int = 10 //声明普通变量
    var ptr *int   //声明指针变量
    var pptr **int //声明指向指针的指针变量
    ptr = &a       //将a的地址赋值给ptr
    pptr = &ptr    //将ptr的地址赋值给pptr
    fmt.Printf("a的值是%d,a的地址是%p\n", a, &a)
    fmt.Printf("*ptr的值是%d,*ptr存储的地址是%p,*ptr的地址是%p\n", *ptr, ptr, &ptr)
    fmt.Printf("**pptr的值是%d,**ptr存储的地址是%p,**ptr的地址是%p\n", **pptr, pptr, &pptr)
    **pptr = 20
    fmt.Println(a, ",", *ptr) //20,20
}

3.数组指针与指针数组

- 数组指针：是一个指针，指向了数组

func main() {
    //创建数组
    var a =[4]int{1,2,3,4}  
    fmt.Printf("数组地址:%p\n",&a)
    //创建一个指针，指向数组
    var p *[4]int
    p=&a
    fmt.Printf("p指向的地址:%p\n",p)
    fmt.Println("p自己的地址:",&p)
    fmt.Println("p指向的值：",*p)
    //用数组指针修改数组
    //1.原生写法
    (*p)[0]=100 
    fmt.Println(a[0])
    //2.简便写法
    p[0]=200
    fmt.Println(a[0])
}

- 指针数组：是一个数组，保存的指针

func main() {
    a:=1
    b:=2
    c:=3
    //创建一个指针数组
    var p=[3]*int{&a,&b,&c}
    fmt.Println(p)
    //通过指针修改a的值
    *p[0]=100
    fmt.Println(a)
    a=200
    fmt.Println(*p[0])
}

4.指针函数

- 函数的返回值是指针

func main() {
    //调用该函数返回的是一个指针
    ptr := p1()
    fmt.Println("ptr指向地址的值", *ptr)
    fmt.Printf("ptr自己内存地址:%p\n", &ptr)
    fmt.Printf("ptr指向的内存地址%p", ptr)
}
//类型为指针的函数
func p1() *[4]int {
    arr := [4]int{1, 2, 3, 4}
    fmt.Printf("arr地址:%p\n", &arr)
    return &arr //返回指针
}

5.指针为函数的参数

- 函数的参数为指针

func main() {
    a :=10
    fmt.Println("a的地址是",&a)
    p1(&a)
}
//参数为指针的函数
func p1(ptr *int)  {
    fmt.Println("ptr存放的地址是",ptr)    
    fmt.Println("ptr的值是",*ptr)  
}