Go语言基础之指针

C/C++中的指针

  1. 说到 C/C++ 中的指针，会让许多人“谈虎色变”，尤其是对指针的偏移、运算和转换。
  2. 其实，指针是 C/C++ 语言拥有极高性能的根本所在，在操作大块数据和做偏移时即方便又便捷。因此，操作系统依然使用C语言及指针的特性进行编写。
  3. C/C++ 中指针饱受诟病的根本原因是指针的运算和内存释放，C/C++ 语言中的裸指针可以自由偏移，甚至可以在某些情况下偏移进入操作系统的核心区域，我们的计算机操作系统经常需要更新、修复漏洞的本质，就是为解决指针越界访问所导致的“缓冲区溢出”的问题。

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

  2. 与 Java 和 .NET 等编程语言不同，Go语言提供了控制数据结构指针的能力。但是并不能进行指针运算。

  3. 指针（pointer）在Go语言中可以被拆分为两个核心概念：

    • 类型指针：允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。
    • 切片：由指向起始元素的原始指针、元素数量和容量组成。C语言中指针可以做运算，但代价是内存操作越界，切片在指针的基础上增加了大小，约束了切片对应的内存区域，切片使用中无法对切片内部的地址和大小进行手动调整，因此切片比指针更安全、强大。

  4. 受益于这样的约束和拆分，Go语言的指针类型变量即拥有指针高效访问的特点，又不会发生指针偏移，从而避免了非法修改关键性数据的问题。同时，垃圾回收也比较容易对不会发生偏移的指针进行检索和回收。

  5. 切片比原始指针具备更强大的特性，而且更为安全。切片在发生越界时，运行时会报出宕机，并打出堆栈，而原始指针只会崩溃。

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

指针也有类型，叫做指针类型。

Go语言中的指针

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

比如，“永远不要高估自己”这句话是我的座右铭，我想把它写入程序中，程序一启动这句话是要加载到内存（假设内存地址0x123456），我在程序中把这段话赋值给变量A，把内存地址赋值给变量B。这时候变量B就是一个指针变量。通过变量A和变量B都能找到我的座右铭。

Go语言中的指针不能进行偏移和运算，因此Go语言中的指针操作非常简单，我们只需要记住两个符号：&（取地址）和*（根据地址取值）。

指针地址和指针类型

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行“取地址”操作。 Go语言中的值类型（int、float、bool、string、array、struct）都有对应的指针类型（在值类型前加了*），如：*int、*int64、*string等。

取变量指针的语法如下：

ptr := &v    // v的类型为T

其中：

  • v:代表被取地址的变量，类型为T
  • ptr:用于接收地址的变量，ptr的类型就为*T，称做T的指针类型。*代表指针。

举个例子：

func main() {
	a := 10
	b := &a
	fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078
	fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int
	fmt.Println(&b)                    // 0xc00000e018
}

我们来看一下b := &a的图示：

指针类型

  1. 一个指针变量（通常缩写为 ptr）可以指向任何一个值的内存地址。

  2. 指针变量指向的值的内存地址在 32 和 64 位机器上分别占用 4 或 8 个字节，占用字节的大小与所指向的值的大小无关。

  3. 当一个指针变量被定义后没有分配到任何变量时，它的默认值为 nil。

var ptr *Type // ptr 的类型为*T，称做 T 的指针类型，*代表指针。

var ptr *int // ptr 的类型为*int，称做 int 的指针类型，*代表指针。

new() 创建指针

  1. Go语言还提供了另外一种方法来创建指针变量。
  2. new() 函数可以创建一个对应类型的指针，创建过程会分配内存，被创建的指针指向默认值。
new(类型)

// demo
str := new(string)
*str = "Go语言教程"
fmt.Println(*str)

指针地址

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用在变量名前面添加&操作符（前缀）来获取变量的内存地址（取地址操作）。

T 代表被取地址的变量，使用变量 ptr 进行接收
ptr := &T

eg:

func main() {
    var cat int = 1
    var str string = "banana"
    fmt.Printf("%p %p", &cat, &str) // 0xc042052088 0xc0420461b0
}

指针取值

在对普通变量使用&操作符取地址后会获得这个变量的指针，然后可以对指针使用*操作，也就是指针取值，代码如下。

func main() {
	//指针取值
	a := 10
	b := &a // 取变量a的地址，将指针保存到b中
	fmt.Printf("type of b: %T\n", b) // type of b: *int
	c := *b // 指针取值（根据指针去内存取值）
	fmt.Printf("type of c: %T\n", c) // type of c: int
	fmt.Printf("value of c: %v\n", c) // value of c: 10
}

输出如下：

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
}

使用

使用指针修改值

// 交换函数
func swap(a, b *int) {
    // 取a指针的值, 赋给临时变量t
    t := *a
    // 取b指针的值, 赋给a指针指向的变量
    *a = *b
    // 将a指针的值赋给b指针指向的变量
    *b = t
}
func main() {
// 准备两个变量, 赋值1和2
    x, y := 1, 2
    // 交换变量值
    swap(&x, &y)
    // 输出变量值
    fmt.Println(x, y) // 2 1
}
  1. *操作符作为右值时，表示是取指向变量的值。
  2. *操作符作为左值时，表示将值设置给指向的变量

如果在 swap() 函数中交换操作的是指针值，会发生什么情况？

func swap(a, b *int) {
    b, a = a, b
}
func main() {
    x, y := 1, 2
    swap(&x, &y)
    fmt.Println(x, y) // 1 2
}
  1. 结果表明，交换是不成功的。
  2. 上面代码中的 swap() 函数交换的是 a 和 b 的地址，在交换完毕后，a 和 b 的变量值确实被交换。但和 a、b 关联的两个变量并没有实际关联。这就像写有两座房子的卡片放在桌上一字摊开，交换两座房子的卡片后并不会对两座房子有任何影响。

new和make进行初始化

没有初始化的指针类型即为对应类型的零值，对于指针即为nil。不能对其进行操作。类似于slice和map没有初始化也不能操作。

我们先来看一个例子：

func main() {
	var a *int // int类型的指针，但是没有初始化，即为nil
    fmt.Println(a)// nil
	*a = 100
	fmt.Println(*a)
	var b map[string]int // 也没有初始化
	b["沙河娜扎"] = 100
	fmt.Println(b)
}

执行上面的代码会引发panic，为什么呢？ 在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。要分配内存，就引出来今天的new和make。 Go语言中new和make是内建的两个函数，主要用来分配内存。

new

针对于基本数据类型，得到的是一个类型的指针，并且该指针对应的值为该类型的零值。

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

func new(Type) *Type {}

其中，

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

new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。举个例子：

func main() {
	a := new(int)
	b := new(bool)
	fmt.Printf("%T\n", a) // *int
	fmt.Printf("%T\n", 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)
}

make

只用于slice、map以及chan(通道)的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型。

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)
}

new与make的区别

  1. 二者都是用来做内存分配的。

  2. make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身；

  3. 而new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。

参考感谢
https://www.liwenzhou.com/posts/Go/07_pointer/
指针 · 语雀 (yuque.com)
Go语言基础之指针 · 语雀 (yuque.com)
make 和 new · 语雀 (yuque.com)
指针 · 语雀 (yuque.com)