Golang指针数组与指针切片操作方法

指针数组和指针切片用于存储指向数据的指针，区别在于长度固定与否；操作时需解引用访问值，传递给函数可修改底层数据，但修改切片结构需返回新切片。

在Golang中，指针数组和指针切片是两种处理指向特定类型数据的集合。它们的核心在于，集合中的每个元素本身不是值，而是一个指向其他内存地址的指针。这意味着你可以通过这些指针间接地访问和修改它们所指向的实际数据，这在需要共享数据、避免大对象拷贝或实现某些特定数据结构时显得尤为重要。理解它们的操作方法，就是掌握如何声明、初始化、赋值以及解引用这些指针元素，从而实现对底层数据的精细控制。

解决方案

操作Golang中的指针数组与指针切片，本质上是围绕“指针”这一概念展开的。

指针数组 (Array of Pointers)

指针数组的声明形式为

*[N]Type

N

Type

立即学习“go语言免费学习笔记（深入）”；

var arr [3]*int // 声明一个包含3个指向int类型指针的数组

初始化和赋值时，你需要为每个数组元素分配一个指针，并让这个指针指向一个具体的内存地址。这个地址可以是一个已存在的变量，也可以是新分配的内存空间。

a, b, c := 10, 20, 30

arr[0] = &a // 让arr[0]指向变量a的地址
arr[1] = &b // 让arr[1]指向变量b的地址

// 也可以直接创建一个新的int变量并取其地址
arr[2] = new(int) // new(int) 返回一个指向新分配int零值的指针
*arr[2] = 40      // 通过解引用指针，给新分配的int赋值

访问和修改元素时，需要先解引用指针，才能操作其指向的实际值。

fmt.Println(*arr[0]) // 输出 10
*arr[0] = 100        // 修改a的值为100
fmt.Println(a)       // 输出 100

需要注意的是，指针数组的长度是固定的，一旦声明就无法改变。

指针切片 (Slice of Pointers)

指针切片的声明形式为

[]*Type

Type

var slice []*string // 声明一个指向string类型指针的切片

初始化时，可以直接使用字面量，或者通过

make

s1 := "hello"
s2 := "world"

slice = []*string{&s1, &s2} // 使用字面量初始化，元素是现有变量的地址

// 或者使用make，但make不会初始化内部指针指向的值，它们默认是nil
slice2 := make([]*int, 2) // 创建一个长度为2的指针切片，元素为nil

向指针切片中添加元素通常使用

append

s3 := "Golang"
slice = append(slice, &s3) // 添加一个指向s3的指针

// 如果切片元素是nil，你需要先分配内存并赋值
slice2[0] = new(int)
*slice2[0] = 50

访问和修改元素与指针数组类似，也需要解引用。

fmt.Println(*slice[0]) // 输出 "hello"
*slice[0] = "你好"      // 修改s1的值为"你好"
fmt.Println(s1)        // 输出 "你好"

指针切片相比指针数组更具灵活性，可以动态增长和缩减，在处理不确定数量的引用数据时更为常用。

何时应该选择使用Golang的指针数组或指针切片？

这确实是个值得深思的问题，因为它直接关系到你的程序设计哲学和性能考量。在我看来，选择指针数组或指针切片，主要取决于你对数据生命周期、修改需求以及集合大小的预知程度。

选择指针数组的场景相对较少，通常是在以下情况：

1. 固定且已知数量的引用： 当你需要一个固定数量的、指向特定类型数据的引用集合，并且这个数量在编译时就确定，那么指针数组可能是个选择。比如，你可能有一个包含N个配置项的列表，每个配置项都是一个复杂结构体的指针，并且这个N永远不会变。
2. 性能敏感的微观优化： 虽然现代Go编译器和运行时已经非常优化，但在极少数对内存布局和访问速度有极致要求的场景下，固定大小的数组可能提供略微更好的局部性或更少的内存管理开销（比如避免切片扩容）。但这通常是过度优化，除非有明确的性能瓶颈。
3. C/C++风格的互操作： 有时为了与C语言的固定大小指针数组进行接口，Go中可能会模拟这种结构。

而指针切片则在绝大多数场景下更具优势，因为它提供了更好的灵活性：

1. 动态数量的引用： 这是最常见的需求。当你需要一个集合来存储任意数量的、指向同一类型数据的引用时，指针切片是首选。例如，一个用户列表，每个用户都是一个

   *User

   结构体，用户数量是动态变化的。
2. 避免大对象拷贝： 当集合中的元素是大型结构体时，如果直接存储值类型切片，每次传递切片（即使是切片头拷贝）或进行append操作时，都可能涉及底层数组的扩容和大量数据拷贝。而存储指针，则只拷贝指针本身（通常是8字节），大大减少了内存开销和性能损耗。
3. 共享和修改数据： 如果你希望通过集合中的元素来修改原始数据（而不是拷贝），那么指针切片是必需的。比如，你有一个

   []*User

   切片，当你修改

   slice[i]

   所指向的

   User

   对象的字段时，所有指向这个

   User

   对象的指针都会看到这些修改。这在构建图结构、链表或需要多处引用同一份数据的场景中非常关键。
4. 函数间传递复杂数据结构： 当你需要在函数间传递一个复杂的数据结构集合，并允许函数内部对这些结构体进行修改时，传递

   []*MyStruct

   是常见的做法。

简单来说，如果你不确定，或者需要灵活性和避免拷贝开销，就选择指针切片。指针数组更像是一种特定场景下的固定结构。

在Golang中操作指针切片时，常见的陷阱和最佳实践有哪些？

指针切片虽然强大，但操作不当也容易引入一些微妙的错误。我见过不少开发者在这里踩坑，所以总结了一些常见的陷阱和对应的最佳实践。

常见陷阱：

1. 忘记初始化指针或解引用： 这是最基础也最常见的错误。

   var pSlice []*int
   pSlice = make([]*int, 1)
   // *pSlice[0] = 10 // 错误：pSlice[0] 此时是 nil，尝试解引用 nil 指针会导致运行时 panic

   make([]*int, 1)

   只是创建了一个包含一个

   nil

   指针的切片。你仍然需要为这个

   nil

   指针分配一个实际的

   int

   内存空间。

2. 循环中取地址的陷阱： 当你在循环中迭代一个值类型切片并尝试获取每个元素的地址时，可能会遇到意想不到的结果。

   

   Jukedeck

   一个由人工智能驱动的音乐创作工具，允许用户为各种项目生成免版税的音乐。

   下载

   values := []int{1, 2, 3}
   var ptrs []*int
   for _, v := range values {
       ptrs = append(ptrs, &v) // 陷阱！
   }
   // 此时 ptrs 中的所有指针可能都指向同一个地址，即循环变量 v 的地址，并且最终都持有最后一个值（3）

   这是因为

   v

   在每次循环迭代中都是同一个变量，只是其值被更新了。所有

   &v

   都指向这个相同的内存地址。

3. 对已销毁对象的指针引用： 虽然Go有垃圾回收，通常不会出现C/C++那样的悬空指针，但在某些高级场景（如使用

   unsafe

   包）或与外部C代码交互时，仍需警惕。一般Go应用中，只要指针指向的对象还在被引用（包括被指针切片引用），GC就不会回收它。

4. 修改切片元素指针，而非指针指向的值：

   type Item struct { ID int }
   items := []*Item{{ID: 1}, {ID: 2}}
   newItem := &Item{ID: 3}
   items[0] = newItem // 此时，items[0] 不再指向 {ID:1}，而是指向 {ID:3}
   // 原来的 {ID:1} 对象如果没被其他地方引用，会被GC回收
   // 但如果你本意是修改 {ID:1} 的 ID 字段，那这就是个错误

   这并不是一个“错误”，而是一个“语义上的误解”。你需要清楚你是想让切片元素指向一个新的对象，还是想修改当前指向对象的内容。

最佳实践：

1. 始终在使用前初始化指针： 当你创建一个指针切片时，即使

   make

   给你预留了空间，每个元素仍然是

   nil

   。在使用

   *slice[i]

   之前，确保

   slice[i]

   指向了一个有效的内存地址。

   pSlice := make([]*int, 1)
   pSlice[0] = new(int) // 分配内存
   *pSlice[0] = 10      // 赋值

   或者直接在

   append

   时传入已分配好并赋值的指针。

2. 循环中正确获取地址：

   values := []int{1, 2, 3}
   var ptrs []*int
   for i := range values { // 遍历索引
       ptrs = append(ptrs, &values[i]) // 获取切片中每个元素的实际地址
   }
   // 或者，为每个值创建新的变量
   for _, v := range values {
       val := v // 创建 v 的一个副本
       ptrs = append(ptrs, &val)
   }

   第一种方法更常见，它直接获取原始切片元素的地址。第二种方法在某些场景下（比如原始切片是值类型，但你希望指针指向一个独立的副本）也很有用。

3. 明确指针切片的目的： 在设计时就想清楚，你是希望切片中的指针指向独立的副本，还是共享的原始数据。

   • 如果希望独立副本，那么在

     append

     或赋值时，需要先创建一个新对象，再取其地址。
   • 如果希望共享，则直接传递现有对象的地址。

4. 善用

   nil

   检查： 在解引用任何指针之前，养成检查其是否为

   nil

   的习惯，尤其是在处理来自外部输入或可能为空的数据时。

   if pSlice[0] != nil {
       fmt.Println(*pSlice[0])
   }

5. 考虑使用值类型切片与传递指针： 有时候，你可能不需要一个完整的指针切片。如果你的操作只需要读取数据，或者修改的只是局部副本，那么一个

   []MyStruct

   的值类型切片，配合函数参数传递

   *MyStruct

   来修改单个元素，可能更清晰。这避免了整个切片都充满指针的复杂性，并且在某些情况下可能受益于更好的缓存局部性。

如何有效地在Golang函数间传递和修改指针数组/切片？

在Go语言中，函数参数传递总是按值进行的。这意味着当你将一个变量传递给函数时，函数接收的是该变量的一个副本。对于指针数组和指针切片来说，这有其独特的含义和操作方式。

传递指针数组：

当你将一个指针数组传递给函数时，实际上是传递了整个数组的一个副本。这意味着函数内部对数组元素（即指针本身）的修改，不会影响到原始数组。然而，如果函数内部通过解引用这些指针修改了它们所指向的数据，那么这些修改会影响到原始数据，因为指针指向的是同一块内存。

func modifyPointerArray(arr [3]*int) {
    // 修改数组元素本身（即让指针指向别处），不会影响原始数组
    newVal := 99
    arr[0] = &newVal // 这里的 arr[0] 是副本，原始数组的 arr[0] 仍指向原来的地址

    // 修改指针指向的值，会影响原始数据
    if arr[1] != nil {
        *arr[1] = 200 // 原始数据被修改
    }
}

func main() {
    a, b, c := 10, 20, 30
    myArr := [3]*int{&a, &b, &c}

    fmt.Println("Before modify:", *myArr[0], *myArr[1]) // 10 20
    modifyPointerArray(myArr)
    fmt.Println("After modify:", *myArr[0], *myArr[1])  // 10 20 (a, b的值被修改为10, 200)
    fmt.Println("Original a, b:", a, b)                // 10 200
}

可以看到，

modifyPointerArray

arr[0]

newVal

main

myArr[0]

a

*arr[1] = 200

main

b

如果需要函数修改指针数组本身（例如，让数组中的某个指针指向新的地址），你需要传递指向数组的指针

*[3]*int

传递指针切片：

传递指针切片时，传递的是切片头（slice header）的一个副本。切片头包含指向底层数组的指针、长度和容量。这意味着函数接收到的是一个独立的切片头，但这个切片头仍然指向与原始切片相同的底层数组。

1. 修改切片元素指向的值： 如果函数通过切片中的指针修改了它们所指向的值，这些修改会反映在原始数据上，因为底层数据是共享的。

   func changeValueInSlice(s []*int) {
       if len(s) > 0 && s[0] != nil {
           *s[0] = 500 // 修改原始数据
       }
   }
   
   func main() {
       x := 100
       mySlice := []*int{&x}
       fmt.Println("Before:", *mySlice[0]) // 100
       changeValueInSlice(mySlice)
       fmt.Println("After:", *mySlice[0])  // 500
       fmt.Println("Original x:", x)      // 500
   }

2. 修改切片头（例如

   append

   操作）： 如果函数内部对切片进行了

   append

   操作，或者重新赋值了切片变量，这只会修改函数内部切片头副本。原始切片在调用函数之后不会被改变，除非你将修改后的切片作为返回值返回。

   func appendToSlice(s []*string) {
       newStr := "world"
       s = append(s, &newStr) // 这里的 s 是副本，只修改了副本的切片头
       fmt.Println("Inside function after append:", *s[len(s)-1]) // "world"
   }
   
   func main() {
       hello := "hello"
       mySlice := []*string{&hello}
       fmt.Println("Before append:", len(mySlice)) // 1
       appendToSlice(mySlice)
       fmt.Println("After append:", len(mySlice))  // 1 (原始切片未改变)
   }

   为了让

   append

   操作影响到原始切片，你需要将函数修改后的切片作为返回值：

   func appendAndReturn(s []*string) []*string {
       newStr := "world"
       s = append(s, &newStr)
       return s
   }
   
   func main() {
       hello := "hello"
       mySlice := []*string{&hello}
       fmt.Println("Before append:", len(mySlice)) // 1
       mySlice = appendAndReturn(mySlice) // 接收返回值
       fmt.Println("After append:", len(mySlice), *mySlice[1]) // 2 "world"
   }

总结与建议：

• 修改底层数据： 无论是指针数组还是指针切片，只要传递了指针，函数内部通过解引用指针进行的底层数据修改，都会影响到原始数据。这是指针的核心用途。
• 修改集合结构（如

  append

  ）： 对于指针数组，如果你想修改数组元素本身（让某个指针指向新的地址），你需要传递

  *[N]*Type

  。对于指针切片，如果你想让

  append

  或其他修改切片长度/容量的操作生效，你需要将修改后的切片作为返回值，或者传递一个指向切片的指针

  *[]*Type

  （尽管这在Go中不常见，通常更推荐返回新切片）。
• 清晰的函数签名： 确保你的函数签名清晰地表达了其意图。如果函数会修改传入切片的底层数据，这应该在文档或函数名中有所体现。如果函数会返回一个新的切片（例如

  append

  后的结果），也应明确。

通常，在Go中，为了修改切片本身（例如增加元素），最惯用的方式是让函数返回修改后的切片。这符合Go的函数式编程倾向，也避免了传递指针的指针可能带来的复杂性。