目录

在 Go 语言中，指针是一种重要的概念。了解和正确使用指针对于理解语言的底层机制、编写高效的代码以及处理复杂数据结构都非常关键。本文将深入探讨 Golang 中指针的概念、用法。

1. 指针的基本概念和语法

指针是一个存储变量内存地址的变量。它提供了直接访问内存中数据的能力，可以用于改变变量的值。在Go语言中，使用 * 表示指针类型，通过 & 操作符获取变量的地址，通过 * 操作符解引用指针获取指针指向的值。

在 Go 语言中，每个变量在运行时都具有一个地址，该地址表示变量在内存中的位置。要对变量进行"取地址"操作，可以在变量前加上 & 字符。此外，Go 语言中的值类型（如 int、float、bool、string、array 和 struct）都有相应的指针类型，分别为 *int、*float64、*bool、*string 等。

1.1 指针的声明和初始化

在 Go 语言中，可以使用指针来引用任何类型的变量。指针的声明和初始化可以通过如下语法完成：

 var p *int  // 声明一个指向 int 类型的指针 p
 var str *string  // 声明一个指向 string 类型的指针 str

初始化指针可以通过 new 函数来分配内存并返回指针的地址：

 p := new(int)  // 分配一个 int 类型的内存，并将指针 p 指向该内存

示例代码：

 package main
 ​
 import "fmt"
 ​
 func main() {
     var p *int
     var str *string
 ​
     fmt.Printf("p: %v, str: %v\n", p, str) // 输出 p: <nil>, str: <nil>
 ​
     x := 10
     p = &x // 将指针p指向变量x的地址
 ​
     fmt.Printf("p: %v\n", p)   // 输出 p: 0xc0000100e0
     fmt.Printf("*p: %d\n", *p) // 输出 *p: 10
 ​
     str = new(string) // 分配一个string类型的内存，并将指针str指向该内存
 ​
     fmt.Printf("str: %v\n", str)   // 输出 str: 0xc000010120
     fmt.Printf("*str: %s\n", *str) // 输出 *str: ""
 ​
     *str = "Hello, Go!" // 通过指针修改字符串的值
 ​
     fmt.Printf("*str: %s\n", *str) // 输出 *str: Hello, Go!
 }

1.2 获取指针的地址和解引用

通过 & 操作符可以获取变量的地址，例如：

x := 10
 p := &x  // 将指针 p 指向变量 x 的地址
 ​
 a := 10
 b := &a // 将指针 b 指向变量 a 的地址

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

使用 * 操作符可以解引用指针，获取指针指向的值：

 fmt.Println(*p)  // 输出指针 p 指向的值，即变量 x 的值

示例代码：

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

输出如下：

type of b:*int
type of c:int
value of c:10

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

1.3 指针作为函数参数

在 Go 语言中，函数的参数传递默认是值传递。如果想要在函数内部修改外部变量的值，可以通过传递指针来实现。

示例代码：

 package main
 ​
 import "fmt"
 ​
 func changeValue(ptr *int) {
     *ptr = 20 // 修改指针指向的值
 }
 ​
 func main() {
     x := 10
     changeValue(&x) // 传递x的地址给changeValue函数
     fmt.Println(x) // 输出修改后的x的值，即20
 }

2. 指针的应用场景

指针在 Go 语言中有着广泛的应用场景，下面将从几个方面介绍指针的常见应用。

2.1 传递大对象

在函数参数传递时，如果直接传递大对象的副本，会产生额外的内存开销。通过传递指针，可以避免复制整个对象，提高程序的性能。

示例代码：

package main
 ​
 import "fmt"
 ​
 type BigObject struct {
     // 大对象的定义...
 }
 ​
 func processObject(obj *BigObject) {
     // 对大对象进行处理...
 }
 ​
 func main() {
     obj := BigObject{}
     processObject(&obj) // 传递大对象的指针
 }

2.2 修改函数外部变量

通过指针，函数可以修改函数外部的变量。这在需要修改外部变量的值时非常有用，特别是在处理复杂数据结构或需要对全局状态进行修改的情况下。

示例代码：

package main
 ​
 import "fmt"
 ​
 func modifyValue(ptr *int) {
     *ptr = 30 // 修改指针指向的值
 }
 ​
 func main() {
     x := 10
     modifyValue(&x) // 传递x的地址给modifyValue函数
     fmt.Println(x) // 输出修改后的x的值，即30
 }

2.3 动态分配内存

指针的另一个重要应用是动态分配内存。通过 new 函数可以在堆上动态分配内存，避免了在栈上分配固定大小的内存空间的限制。这对于需要返回动态分配的数据或创建复杂数据结构非常有用。

示例代码：

 package main
 ​
 import "fmt"
 ​
 type ComplexStruct struct {
     // 复杂数据结构的定义...
 }
 ​
 func createComplexStruct() *ComplexStruct {
     cs := new(ComplexStruct) // 动态分配内存并返回指针
     // 初始化复杂数据结构...
     return cs
 }
 ​
 func main() {
     obj := createComplexStruct()
     // 对动态分配的数据结构进行操作...
 }

2.4 函数返回指针

在函数中返回指针可以将函数内部创建的变量的地址传递给调用者。这样做可以避免复制整个变量，并允许调用者直接访问和修改函数内部的数据。

示例代码：

package main
 ​
 import "fmt"
 ​
 func createValue() *int {
     x := 10 // 在函数内部创建变量
     return &x // 返回变量的地址
 }
 ​
 func main() {
     p := createValue()
     fmt.Println(*p) // 输出通过指针访问的函数内部变量的值，即10
 }

3. new 和 make

我们先来看一个例子：

func main() {
     var a *int
     *a = 100
     fmt.Println(*a)
 ​
     var b map[string]int
     b["沙河娜扎"] = 100
     fmt.Println(b)
 }

执行上面的代码会引发 panic，为什么呢？在 Go 语言中，对于引用类型的变量，在使用之前需要先进行声明，并为其分配内存空间，否则无法存储值。而对于值类型的声明，无需手动分配内存空间，因为它们在声明时已经默认分配了内存空间。为了分配内存空间，我们可以使用 Go 语言中内建的两个函数：new 和 make。这两个函数具有不同的用途，new 主要用于分配值类型的内存空间，而 make 主要用于分配引用类型（如 slice、map 和 channel）的内存空间。

3.1 new

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

func new(Type) *Type

Type 表示类型，new 函数只接受一个参数，这个参数是一个类型，*Type 表示类型指针，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
 }

3.2 make

make 也是用于内存分配的，区别于 new，它只用于 slice、map 以及 channel 的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。make 函数的函数签名如下：

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

make 函数是无可替代的，我们在使用 slice、map 以及 channel 的时候，都需要使用 make 进行初始化，然后才可以对它们进行操作。

示例代码：

 func main() {
     var b map[string]int
     b = make(map[string]int, 10)
     b["沙河娜扎"] = 100
     fmt.Println(b)
 }

4. 总结

指针是 Go 语言中一种重要的概念，它提供了直接访问内存和修改变量值的能力。正确使用指针可以提高程序的性能、处理复杂数据结构以及实现并发编程中的数据共享和同步。

在编写代码时，我们应该充分理解指针的特性和使用注意事项，避免指针引起的错误和不确定性。合理使用指针将帮助我们编写出高效、可靠且易于维护的 Go 语言程序。

您可能感兴趣的文章: