深入理解Golang中指针的用途与技巧

在 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 语言程序。

来源：https://juejin.cn/post/7236213437801087031