3.1 Go语言基础之指针

zoukankan html css js c++ java

3.1 Go语言基础之指针
区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针。

要搞明白Go语言中的指针需要先知道3个概念：指针地址、指针类型和指针取值。

一、Go语言中的指针

Go语言中的函数传参都是值拷贝，当我们想要修改某个变量的时候，我们可以创建一个指向该变量地址的指针变量。传递数据使用指针，而无须拷贝数据。类型指针不能进行偏移和运算。Go语言中的指针操作非常简单，只需要记住两个符号：&（取地址）和*（根据地址取值）。

二、指针地址

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行“取地址”操作。

取变量指针的语法如下：
```
ptr := &v    // v的类型为T
```
其中：
- v:代表被取地址的变量，类型为T
- ptr:用于接收地址的变量，ptr的类型就为*T，称做T的指针类型。*代表指针。
举个例子：
```
func main() {
	a := 10
	b := &a
	fmt.Printf("a:%d ptr:%p
", a, &a) // a:10 ptr:0xc00001a078
	fmt.Printf("b:%p type:%T
", b, b) // b:0xc00001a078 type:*int
	fmt.Println(&b)                    // 0xc00000e018
}
```
我们来看一下b := &a的图示：

三、指针类型

3.1 定义
- 普通变量存储的是对应类型的值，这些类型就叫值类型；
- 指针类型的变量存储的是一个地址，所以又叫指针类型或引用类型；（任何类型都可以有指针类型，对于所有类型指针类型都生效）比如说：Go语言中的值类型（int、float、bool、string、array、struct）都有对应的指针类型，如：int、int64、*string等。
- 指针类型默认值为nil（空内存地址0x0）
a就是一个指针类型，存储的是内存地址，b是一个值类型，存储的是对应的值。

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

import (
    "fmt"
)

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

3.2 声明定义

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

实例：
```
package main

import (
    "fmt"
)

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

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

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

3.3 指针初始化

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

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

3.4 指针类型变量的默认值

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

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

实例：
```
package main

import (
    "fmt"
)

func main() {
    var a *int //只是定义了一个指针a
    *a = 100   //现在修改指针a，但指针a是空，必然会报错
    fmt.Printf("%d
", *a)
}
```
执行结果如下：

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

import (
    "fmt"
)

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

四、指针取值

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

注意：

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

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

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

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

实例：
```
package main

import "fmt"

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

	*a = 90 //修改指针变量的存的内存地址所对应的值
	fmt.Println("address of b is", b)
}
```
执行结果如下图所示：

4.2 通过指针修改变量的值

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

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

实例：
```
package main

import (
    "fmt"
)

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

4.3 指针变量传参

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

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

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

实例1：
```
package main

import (
    "fmt"
)

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

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

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

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

    modify2(p)
    fmt.Printf("b=%d
", b)
}
```
执行结果如下：

解释：

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

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

实例2：
```
package main

import (
    "fmt"
)

func change(val *int) {
    *val = 55 //修改指针多存的内存地址对应的值
}
func main() {
    a := 58
    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)
}
```
执行结果如下：

实例3：
```
package main

import (
    "fmt"
)

func modify(arr *[3]int) {
    (*arr)[0] = 90
}
func main() {
    a := [3]int{89, 90, 91}
    modify(&a)   //传递的是内存地址所以可以修改
    fmt.Println(a)
}
```
执行结果如下：

4.4 切片传参

实例：
```
package main

import (
    "fmt"
)

func modify(sls []int) {
    sls[0] = 90
}
func main() {
    a := [3]int{89, 90, 91}
    modify(a[:]) //切片是引用类型，所以底层也是指针，所以是可以修改的，修改是生效的
    fmt.Println(a)
}
```
执行结果如下：

4.5 总结

在对普通变量使用&操作符取地址后会获得这个变量的指针，然后可以对指针使用*操作，也就是指针取值，代码如下。
```
func main() {
	//指针取值
	a := 10
	b := &a // 取变量a的地址，将指针保存到b中
	fmt.Printf("type of b:%T
", b)
	c := *b // 指针取值（根据指针去内存取值）
	fmt.Printf("type of c:%T
", c)
	fmt.Printf("value of c:%v
", c)
}
```
输出如下：
```
type of b:*int
type of c:int
value of c:10
```
总结： 取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。

变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：
- 对变量进行取地址（&）操作，可以获得这个变量的指针变量。
- 指针变量的值是指针地址。
- 对指针变量进行取值（*）操作，可以获得指针变量指向的原变量的值。
指针传值示例：
```
func modify1(x int) {
	x = 100
}

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

func main() {
	a := 10
	modify1(a)
	fmt.Println(a) // 10
	modify2(&a)
	fmt.Println(a) // 100
}
```
五、new和make

我们先来看一个例子：
```
func main() {
	var a *int
	*a = 100
	fmt.Println(*a)

	var b map[string]int
	b["北京哈登"] = 100
	fmt.Println(b)
}
```
执行上面的代码会引发panic，为什么呢？在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。要分配内存，就引出来今天的new和make。 Go语言中new和make是内建的两个函数，主要用来分配内存。

5.1 new

new是一个内置的函数，它的函数签名如下：
```
func new(Type) *Type
```
其中，
- Type表示类型，new函数只接受一个参数，这个参数是一个类型
- *Type表示类型指针，new函数返回一个指向该类型内存地址的指针。
new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。举个例子：
```
func main() {
	a := new(int)
	b := new(bool)
	fmt.Printf("%T
", a) // *int
	fmt.Printf("%T
", b) // *bool
	fmt.Println(*a)       // 0
	fmt.Println(*b)       // false
}	
```
本节开始的示例代码中var a *int只是声明了一个指针变量a但是没有初始化，指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。应该按照如下方式使用内置的new函数对a进行初始化之后就可以正常对其赋值了：
```
func main() {
	var a *int
	a = new(int)
	*a = 10
	fmt.Println(*a)
}
```
5.2 make

make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。make函数的函数签名如下：
```
func make(t Type, size ...IntegerType) Type
```
make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作。这个我们在上一章中都有说明，关于channel我们会在后续的章节详细说明。

本节开始的示例中var b map[string]int只是声明变量b是一个map类型的变量，需要像下面的示例代码一样使用make函数进行初始化操作之后，才能对其进行键值对赋值：
```
func main() {
	var b map[string]int
	b = make(map[string]int, 10)
	b["哈登"] = 100
	fmt.Println(b)
}
```
5.3 new与make的区别
1. 二者都是用来做内存分配的。
2. make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身；
3. 而new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。
换一种说法：

简单来说，

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

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

下面通过这个实例来深入理解下：
```
package main

import (
    "fmt"
)

type User struct {
    Name string
    age  int
}

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

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

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

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

    (*p)[0] = 100
    (*p)[2] = 100

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

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

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

func main() {
    test1()
    test2()
}
```
执行结果如下：

六、值拷贝和引用拷贝

6.1 值拷贝

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

实例1：
```
package main

import (
    "fmt"
)

func main() {
    var a int = 100
    fmt.Printf("a addr is %p
", &a)
    b := a
    fmt.Printf("b addr is %p
", &b)
    a = 50
    fmt.Printf("a addr is %p
", &a)
    fmt.Printf("a=%d b=%d", a, b)
}
```
执行结果如下：

解释：

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

6.2 引用拷贝

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

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

import (
    "fmt"
)

func main() {
    var a int = 100
    var b *int = &a
    var c *int = b
    *c = 200
    fmt.Printf("a=%v b=%v c=%v", a, *b, *c)
}
```
执行结果如下：

解释:

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

相关阅读:
Swift
Swift
书籍
 Swift
Swift
iOS系统架构
 Reveal真机(越狱)查看任意APP
Swift
Swift
Swift

原文地址：https://www.cnblogs.com/forever521Lee/p/11132310.html

3.1 Go语言基础之指针

一、Go语言中的指针

二、指针地址

三、指针类型

3.1 定义

3.2 声明定义

3.3 指针初始化

3.3.1 方法1

3.3.2 方法2 new

3.4 指针类型变量的默认值

四、指针取值

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

4.2 通过指针修改变量的值

4.3 指针变量传参

4.4 切片传参

4.5 总结

五、new和make

5.1 new

5.2 make

5.3 new与make的区别

六、值拷贝和引用拷贝

6.1 值拷贝

6.2 引用拷贝