9-指针¶

区别于C/C++中的指针，Go中的指针不能进行偏移和运算，是安全指针，

任何程序数据载入内存后，在内存都有他们的地址，这就是指针。为了保存一个数据在内存中的地址，我们就需要指针。

Go 中的指针操作非常简单：&取地址符、*根据地址取值。

Warning

指针是值类型！！！

定义指针、指针取地址¶

var idn *T
var idn *T = &variable
idn := &variable

idn：指针名、T指针基类型、*T某类型指针、variable：变量、&variable：取变量地址

Go 中的值类型（int、float、bool、string、数组、struct结构体）都有对应类型指针，如 *int、*float、*string、*bool、*[5]int。

func main() {
    i := 1
    var p *int = &i

    fmt.Printf("i:     %d \n", i)      // i:    1 
    fmt.Printf("iaddr: %p \n", &i)     // addr: 0xc000012090 
    fmt.Printf("p:     %p \n", p)      // p:    0xc000012090
    fmt.Printf("paddr: %p \n", &p)     // addr: 0xc000006028 
    fmt.Printf("pint Type: %T \n", p)  // pint Type: *int
}

指针取值¶

定义指针之后，就可以对指针进行操作了。指针的操作有两种：&取地址、*根据地址取值

func main() {

    // 指针取值
    a := 10
    b := &a
    fmt.Println(b)  // b 中保存着 a 的地址
    fmt.Println(&a) // 取 a 的地址
    fmt.Println(a)  // a 的值
    fmt.Println(*b) // 取 b
}

// ------------------------------------
// Output:
0xc000012090
0xc000012090
10
10

取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。

变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：

对变量进行取地址（&）操作，可以获得这个变量的指针变量。
指针变量的值是指针地址。
对指针变量进行取值（*）操作，可以获得指针变量指向的原变量的值。

结构体指针¶

结构体指针访问结构体字段同结构体变量访问结构体字段一样，使用 . 点操作符，Go 没有 -> 操作符。

eg:

type User struct {    // 定义结构体
    name string
    age  int
}

Boii := User {    // 定义结构体变量
    name: "Boii",
    age:  18
}

p := &Boii    // 定义结构体指针

fmt.Println(p.name)    // 用 . 点操作符访问成员 Boii

指针做形参¶

func fn1(x int) {
    x = 100
}

func fn2(x *int) {
    *x = 100
}

func main() {
    var a int = 10
    fn1(a)
    fmt.Println(a) // 10

    var b *int = &a
    fn2(b)
    fmt.Println(a) // 100
}

指针做返回值¶

Go 允许使用“栈逃逸”机制将局部变量的空间分配在堆上。使用这种机制，需要返回指针

eg：

func add(a, b int) *int {
    sum := a + b
    return &sum
}

func main() {
    psum := add(10, 20)
    fmt.Println(psum)  // 0xc000012090
    fmt.Println(*psum) // 30
}

new 和 make¶

new¶

new 是一个内置函数，它的函数签名如下：

func new(Type) *Type

Type 表示类型，new函数只接收一个参数，这个参数只能是类型 *Type 表示类型指针，new 函数返回一个指向该类型内存地址的指针

new函数可以接受所有类型，使用new函数可以得到类型的指针，并且这个指针指向的内存地址中存着该类型的零值。

func main() {
    a := new(int)
    b := new([5]int)
    c := new([]string)
    d := new(map[int]string)
    fmt.Printf("a type: %T \n", a) // a type: *int
    fmt.Printf("b type: %T \n", b) // b type: *[5]int
    fmt.Printf("c type: %T \n", c) // c type: *[]string
    fmt.Printf("d type: %T \n", d) // d type: *map[int]string

    fmt.Println(*a) // 0
    fmt.Println(*b) // [0 0 0 0 0]
    fmt.Println(*c) // []
    fmt.Println(*d) // map[]
}

new 函数会开辟一块空间，然后把这块空间的地址返回出去，这样外面的指针变量（a、b、c、d）就可以操作了。如果仅仅只是声明一个指针变量，而没有开辟内存空间，这个指针变量是无法使用的。

以下为错误示例：

func main() {
    var i *int
    fmt.Println(i)
    *i = 10    // 这里会引发 panic
}

// ------------------------------------
// Output:
<nil>
panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xc0000005 code=0x1 addr=0x0 pc=0x97581b]

goroutine 1 [running]:
main.main()
    e:/---CODE/GO/src/Hello/main.go:23 +0x7b
exit status 2

从上面例子可以看到，声明了一个指针，默认值为 nil。在没有分配内存的情况下去使用指针，会导致 panic。

以下为正确示例：

func main() {
    var i *int          // 声明一个指针变量
    fmt.Println(i)      // <nil> | 默认值为 nil
    i = new(int)        // 给这个指针分配内存
    *i = 10             // 存个值进去
    fmt.Println(i)      // 0xc000012098 | 已经有内存空间了
    fmt.Println(*i)     // 10 | 正常~~
}

make¶

make 也是用于分配内存，但是只能用于slice切片、map字典、chan通道的内存创建，而且它返回的类型就是这三个类型本身，因为这三种类型就是引用类型，所以没必要返回他们的指针了。

make 的函数签名如下：

func make(t Type, size ...IntegerType) Type

在使用 slice、map、chan的时候，都需要使用 make 进行初始化，然后才可以对它们进行操作

func main() {
    c := new([]string)
    s := make([]string, 10)
    d := new(map[int]string)
    e := make(map[int]string)

    fmt.Printf("c type: %T \n", c) // c type: *[]string    | string切片类型的指针
    fmt.Printf("s type: %T \n", s) // s type: []string     | string切片
    fmt.Printf("d type: %T \n", d) // d type: *map[int]string | map类型的指针
    fmt.Printf("e type: %T \n", e) // e type: map[int]string  | map
}

new 和 make 的区别¶

new 返回的是指针，make返回的是 类型本身
new 可以给所有类型的 指针开辟空间，make 只能用于 slice、map、chan的 初始化