go七：指针

package main

import "fmt"

func main() {
    a := 120
    //声明一个指针变量
    var ip *int
    //给指针变量赋值：将变量a的内存地址赋值给ip
    ip = &a
    //打印a的类型和值
    fmt.Printf("a的类型是%T，值是%v\n", a, a)  //int 120
    fmt.Printf("&a的类型是%T，值是%v\n", &a, &a)  //*int 0xc42154004145
    fmt.Printf("ip的类型是%T，值是%v\n", ip, ip)  //*int 0xc42154004145
    fmt.Printf("*ip的类型是%T，值是%v\n", *ip, *ip)  //int 120
    fmt.Printf("*&a的类型是%T，值是%v\n", *&a, *&a)  //int 120
    fmt.Println("===========")
    fmt.Println(a, &a, *&a)  //120 0xc04204c080 120
    fmt.Println(ip, &ip, *ip, *(&ip), &(*ip))  //0xc04204c080 0xc04206c018 120 0xc04204c080 0xc04204c080
    }

package main

import "fmt"

type Student struct {
    name string
    age int
    married bool
    sex int8
}
func main() {
    s1 := Student{"candy", 35,true, 1 }
    s2 := Student{"sunny", 30,false, 0 }
    //定义一个指针
    var a *Student = &s1
    var b *Student = &s2
    fmt.Printf("s1类型为%T, 值为%v\n", s1, s1)
    fmt.Println("================\n")
    fmt.Printf("a类型为%T, 值为%v\n", a, a)
    fmt.Printf("b类型为%T, 值为%v\n", b, b)
    fmt.Println("================\n")
    fmt.Printf("*a类型为%T, 值为%v\n", *a, *a)
    fmt.Printf("*b类型为%T, 值为%v\n", *b, *b)
    }

s1类型为main.Student, 值为{candy 35 true 1}
================
a类型为*main.Student, 值为&{candy 35 true 1}
b类型为*main.Student, 值为&{sunny 30 false 0}
================
*a类型为main.Student, 值为{candy 35 true 1}
*b类型为main.Student, 值为{sunny 30 false 0}

 

 操作指针：

指针作为函数参数传递

package main

import "fmt"

func main() {
    a := 10
    fmt.Println("函数调用前的a值", a) //10
    b := &a
    change(b)
    fmt.Println("函数调用之后的a值", a) //20
}
func change(num *int) {
    *num = 20
}

package main

import "fmt"

func main() {
    //定义两个局部变量
    a, b := 100, 200
    a, b = swap0(a, b)
    fmt.Println("返回值的写法实现的数据交换a, b: ", a, b) //200 100
    swap(&a, &b)
    fmt.Println("使用指针的写法实现的数据交换a, b: ", a, b) //100 200
}
//传统写法，具有返回值的惯用写，实现两个数据的交换
func swap0(x, y int) (int, int) {
    return y, x
}
//使用指针作为参数的写，无需返回值
func swap(x, y *int) {
    *x, *y = *y, *x
}

 

切片指针作为函数参数。但惯用用法，使用切片作为函数参数，而不是切片的指针作为函数参数

package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    fmt.Println("调用函数前的切片为：", a)  //[1 2 3 4]
    modify(&a)
    fmt.Println("调用函数后的切片为：", a)  //[600 2 3 4]
}
func modify(arr *[]int) {
    (*arr)[0] = 600
}

指针数组：元素为指针类型的数组

package main

import "fmt"

const COUNT int = 4

func main() {
    //数组
    a := [COUNT]string{"abc", "ABC", "123", "一二三"}
    //查看数组指针的类型和值
    fmt.Printf("数组的指针：%T, %v\n", a, a)

    //定义指针数组
    var ptr [COUNT]*string
    fmt.Printf("指针数组：%T, %v\n", ptr, ptr)

    for i := 0; i < COUNT; i++ {
        //将数组中每个元素的地址，依次赋值给指针数组的每个元素
        ptr[i] = &a[i]
    }
    fmt.Printf("赋值后的指针数组：%T, %v\n", ptr, ptr)
    fmt.Println(ptr[0])

    //根据指针数组元素的每个地址获取该 地址所指向的元素的真实数值
    for i := 0; i < COUNT; i++ {
        fmt.Printf("赋值后的指针数组指向的真实数据：%T, %v\n", *ptr[i], *ptr[i])
    }
    fmt.Printf("=============\n")
    for _, value := range ptr {
        fmt.Printf("赋值后的指针数组指向的真实数据：%T, %v\n", *value, *value)
    }
}

数组的指针：[4]string, [abc ABC 123 一二三]
指针数组：[4]*string, [<nil> <nil> <nil> <nil>]
赋值后的指针数组：[4]*string, [0xc042048080 0xc042048090 0xc0420480a0 0xc0420480b0]
0xc042048080
赋值后的指针数组指向的真实数据：string, abc
赋值后的指针数组指向的真实数据：string, ABC
赋值后的指针数组指向的真实数据：string, 123
赋值后的指针数组指向的真实数据：string, 一二三
=============
赋值后的指针数组指向的真实数据：string, abc
赋值后的指针数组指向的真实数据：string, ABC
赋值后的指针数组指向的真实数据：string, 123
赋值后的指针数组指向的真实数据：string, 一二三

 指针的指针：

package main

import "fmt"

func main() {
    var a int
    var ptr *int
    var pptr **int

    a = 123
    //为指针赋值
    ptr = &a
    //为指针的指针赋值
    pptr = &ptr

    fmt.Println("a: ", a, "ptr: ", ptr, "pptr: ", pptr) //a:  123 ptr:  0xc04204c080 pptr:  0xc04206c018
    //获取指针对应的值
    fmt.Printf("变量a=%d \n", a)
    fmt.Printf("指针变量*ptr=%d \n", *ptr)
    fmt.Printf("指针的指针变量**pptr=%d \n", **pptr)
}