Go语言基础之9--指针类型详解

一、 变量和内存地址

每个变量都有内存地址，可以说通过变量来操作对应大小的内存

注意：通过&符号可以获取变量的内存地址

通过下面例子来理解下：

实例1-1

package main

import (
    "fmt"
)

func main() {
    var a int32 =
    fmt.Printf("%d\n", a)
    fmt.Printf("%p\n", &a)
}

执行结果如下图所示：

二、 指针类型

2.1 定义

普通变量存储的是对应类型的值，这些类型就叫值类型；

指针类型的变量存储的是一个地址，所以又叫指针类型或引用类型；（任何类型都可以有指针类型，对于所有类型指针类型都生效）

32位操作系统内存占4字节，64位操作系统占8字节；

指针类型默认值为nil（空内存地址0x0）

a就是一个指针类型，存储的是内存地址，b是一个值类型，存储的是对应的值。

下面通过一个实例再来理解一下：

实例2-1

package main

import (
    "fmt"
)

func main() {
    var b int32 //b为值类型，存储的是对应的值
    b =
    var a *int32 //a为指针类型，存储的是内存地址
    fmt.Printf("addr of a:%v\n", a) //指针a未赋值，其的默认值为nil，也就是空内存地址0x0
    a = &b //a目前是一个指针，打印出来的也就是b（通过&取的内存地址）的内存地址
    fmt.Printf("%v\n", a)
    fmt.Printf("%v\n", *a) //*a表示取指针类型里指向的那块内存地址所对应的值
}

执行结果如下：

2.2 声明

指针类型定义， var 变量名 *类型

实例2-2

package main

import (
    "fmt"
)

func main() {
    var a *int
    var b int = 

    a = &b
    fmt.Printf("value of a %v\n", a)  //打印的是指针a的值
    fmt.Printf("address of b %v\n", &b) //打印的是变量b的内存地址
    fmt.Printf("address of a %v\n", &a)  //打印指针a的内存地址

    *a =    //修改指针a存的内存地址所对应的值的值（其实就是修改b）
    fmt.Printf("value of b %v\n", b)  //打印变量b看是否修改成功
    fmt.Printf("type of a %T\n", a)  //%T能够打印变量的类型
}

执行结果如下：

2.3 指针初始化

2.3.1 方法1

var a *int = &b

再定义指针a之后，我们必须要为其初始化（不初始化，是一个空内存地址，程序会直接崩溃），也就是为其赋值，这里我们为指针a传入的是一个内存地址（也就分配了内存了），因为变量b在定义时已经为其分配了内存，这里是把变量b的内存地址赋值给了指针a；

2.3.2 方法2 new

var p *int = new(int)

变量p此时为指针，其指向的是一个类型为int的内存地址（底层new为其分配内存地址，做了初始化），然后就可以对指针p进行操作了

2.4 指针类型变量的默认值

指针类型变量的默认值为nil，也就是空地址0x0。所有操作都是有内存才能操作。

下面通过一个实例来验证下对一个空地址操作，程序就会崩溃：

实例2-3

package main

import (
    "fmt"
)

func main() {
    var a *int //只是定义了一个指针a
    *a =    //现在修改指针a，但指针a是空，必然会报错
    fmt.Printf("%d\n", *a)
}

执行结果如下：

所以我们写程序一定要严谨，加上判断，可见如下例子：

实例2-4

package main

import (
    "fmt"
)

func main() {
    a :=
    var b *int
    if b == nil { //如果指针a是空地址，就为其赋值，不然程序会崩溃
        fmt.Printf("b is %v\n", b)
        b = &a
        fmt.Printf("b after initialization is %v\n", b)
    }
}

执行结果如下：

2.5 操作指针变量指向的地址里面的值

注意：通过* 符号可以获取指针变量指向的变量

*指针变量：就能够获得指针变量中存的内存地址对应的值。

如果想要修改指针变量的存的内存地址所对应的值？

方法：*指针变量 = 要修改的值

实例2-5

package main

import (
    "fmt"
)

func main() {
    b :=
    a := &b
    fmt.Println("address of b is", a)
    fmt.Println("value of b is", *a) //获取指针变量中存的内存地址对应的值

    *a =  //修改指针变量的存的内存地址所对应的值
    fmt.Println("address of b is", b)
}

执行结果如下图所示：

2.6 通过指针修改变量的值

如果想要修改指针变量的存的内存地址所对应的值？

方法：*指针变量 = 要修改的值

实例2-6

package main

import (
    "fmt"
)

func main() {
    b :=
    a := &b
    fmt.Println("address of b is", a)
    fmt.Println("value of b is", *a)
    *a++  //修改指针变量的存的内存地址所对应的值
    fmt.Println("new value of b is", b)
}

执行结果如下：

2.7 指针变量传参

1、如果是一个值类型，通过函数是改不了他的值。

2、无论是指针类型还是值类型，函数传参都是会拷贝，只不过指针类型拷贝的是内存地址，无论指针类型的内存地址指向的那个值有多大，指针类型永远是拷贝8个字节（64位操作系统 int64   32位操作系统是4个字节 int32），所以说如果指针类型指向的那块内存地址存的值很大的话，指针传值性能更高。

下面通过这个例子来详细解释下：

实例2-7         实例1

package main

import (
    "fmt"
)

func modify(a int) {
    fmt.Printf("2. address of a=%p, value of a:%v\n", &a, a)
    a =
}

func modify2(a *int) {
    fmt.Printf("4. address of a:%v, value of a :%v\n", &a, a)
    *a =
}

func main() {
    var b int =
    fmt.Printf("1. address of b=%p, value of b:%v\n", &b, b)
    modify(b)

    var p *int = &b
    fmt.Printf("3. address of p:%v, value of p:%v\n", &p, p)

    modify2(p)
    fmt.Printf("b=%d\n", b)
}

执行结果如下：

解释：

1、函数传参是值的拷贝，只不过值类型传递的是值，指针类型（引用类型）传递的是内存地址。

2、定义b为100，当首先执行modify函数时，传递的是b的副本，所以无论函数中怎么修改，是不影响变量b值本身的。在经过modify2函数执行后，虽然传递的也是副本，但是传递的是b的内存地址，而函数又是基于该内存地址进行修改的，所以值由100修改为了1000

实例2-8   实例2

package main

import (
    "fmt"
)

func change(val *int) {
    *val =  //修改指针多存的内存地址对应的值
}
func main() {
    a :=
    fmt.Println("value of a before function call is", a)
    b := &a //传入a的内存地址
    change(b)
    fmt.Println("value of a after function call is", a)
}

执行结果如下：

实例2-9    实例3

package main

import (
    "fmt"
)

func modify(arr *[]int) {
    (*arr)[] =
}
func main() {
    a := []int{, , }
    modify(&a)   //传递的是内存地址所以可以修改
    fmt.Println(a)
}

执行结果如下：

2.8 切片传参

实例2-10

package main

import (
    "fmt"
)

func modify(sls []int) {
    sls[] =
}
func main() {
    a := []int{, , }
    modify(a[:]) //切片是引用类型，所以底层也是指针，所以是可以修改的，修改是生效的
    fmt.Println(a)
}

执行结果如下：

三、 make和new的区别

1、make用来分配引用类型的内存，比如 map、 slice以及channel，make除了分配内存外，还为这些复杂的数据类型（底层结构复杂，有很多字段在里面）做初始化

2、new用来分配除引用类型的所有其他类型的内存，比如 int、数组等，其实new可以为任何类型的分配内存，只不过针对引用类型（切片、map）来说，new虽然可以为其分配内存，但是其还是需要借助make去初始化。

通过下面这个实例深入理解：

实例3-1

package main

import (
    "fmt"
)

type User struct {
    Name string
    age  int
}

func test1() {
    var p *int = new(int)
    *p =
    fmt.Printf("p:%v address:%v\n", *p, p)

    var pUser *User = new(User)
    (*pUser).age =
    pUser.Name = "user01"   //正常来说规范写应该是(*pUser).Name，但是go语言针对结构体这里做了优化（切片、map不可以，依然需要规范写），可以简化写。

    fmt.Printf("user:%v\n", *pUser)
}

func test2() {
    var p *[]int = new([]int) //new为切片分配内存
    *p = make([]int, )      //切片需要make为其初始化才能使用

    (*p)[] =
    (*p)[] = 

    fmt.Printf("p:%#v\n", *p)

    var p1 *map[string]int = new(map[string]int) //new为map分配内存
    *p1 = make(map[string]int, )               //map需要make为其初始化才可以使用
    (*p1)["key"] =
    (*p1)["key2"] = 

    fmt.Printf("p:%#v\n", *p1)
}

func main() {
    test1()
    test2()
}

执行结果如下：

四、 值拷贝和引用拷贝

4.1 值拷贝

值类型拷贝，相当于完全拷贝一份（有副本存在），当对副本进行修改时，无论如何是不影响变量本身的。

实例4-1

package main

import (
    "fmt"
)

func main() {
    var a int =
    fmt.Printf("a addr is %p\n", &a)
    b := a
    fmt.Printf("b addr is %p\n", &b)
    a =
    fmt.Printf("a addr is %p\n", &a)
    fmt.Printf("a=%d b=%d", a, b)
}

执行结果如下：

解释：

正如此题，a赋值给b，其做的就是一个值拷贝，b就相当于是拷贝的这个副本，无论b如何变化，是不影响a本身的，本身他们就是2块独立的内存地址。所以a的值在变化后，b是不受影响的。

4.2 引用拷贝

引用拷贝，拷贝的是内存地址，所以当其中一个变量修改了，另一个变量也会修改，因为他们对应的是同一个内存地址。

通过如下例子再来理解一下：

实例4-2

package main

import (
    "fmt"
)

func main() {
    var a int =
    var b *int = &a
    var c *int = b
    *c =
    fmt.Printf("a=%v b=%v c=%v", a, *b, *c)
}

执行结果如下：

解释:

我们可以发现a、b和c都是同事指向同一内存地址，一旦对任何一个变量修改，另外两个变量也会修改。