Golang指针数组与切片对比解析

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《Golang指针数组与切片区别详解》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

指针数组是固定大小的指针容器，内存连续且不可变；指针切片是动态可变的指针集合，支持灵活扩容与操作，适用于数量不确定的场景。

在Golang的世界里，指针是绕不开的话题，而当指针与数组、切片这两种数据结构结合时，很多初学者，甚至一些有经验的开发者，都会感到一丝困惑。究其核心，"指针数组"（[N]*T）和"指针切片"（[]*T）之间的区别，可以概括为：前者是一个固定大小的容器，其每个槽位都存放着一个指向特定类型数据的指针；而后者则是一个动态可变的容器，它的每个元素同样是指针，但其自身的长度和容量可以根据需求灵活调整。理解它们，关键在于把握“固定与动态”、“容器本身”与“容器元素”这两个维度。

解决方案

要深入理解这两种结构，我们不妨从它们的声明、内存布局以及实际操作的层面进行剖析。指针数组，顾名思义，它首先是一个数组。这意味着一旦你声明了 var arr [3]*int，你就拥有了一个包含三个 *int 类型元素的数组，这个数组的大小是固定的，不可更改。这三个 *int 元素各自可以指向一个整数值，或者保持为 nil。它的内存分配是连续的，所有指针本身存储在一起。

相比之下，指针切片 []*T 则展现出截然不同的动态性。它是一个切片，这意味着它拥有一个指向底层数组的指针、一个长度（len）和一个容量（cap）。当声明 var s []*int 时，你得到的是一个初始为空的切片。你可以通过 append 操作向其中添加 *int 类型的元素，切片会根据需要自动扩容，其底层数组可能会在内存中重新分配。这里的每个元素同样是一个 *int，指向某个整数值。

所以，最直观的区别就是：数组的“骨架”是死的，切片的“骨架”是活的。但无论是哪种，它们内部存储的都是指针，这些指针才指向真正的数据。这带来一个有趣的现象：即使切片本身重新分配了底层数组，其内部的指针依然指向最初的那些数据，除非你显式地修改这些指针所指向的内容。

Golang中“指针数组”究竟意味着什么？（[N]*T 的深层解析）

说起指针数组，我总觉得它带有一种古典的、固定的美感。[N]*T 这种结构，本质上是一个类型为 T 的指针的数组。这意味着，这个数组的每一个“格子”里，都老老实实地放着一个指向 T 类型数据的地址。它的固定性是其最显著的特征：一旦定义，其大小 N 就被焊死了，不能增也不能减。

从内存层面看，当你声明 var arr [5]*string 时，Go 会在栈上（如果它是一个局部变量）或者静态存储区（如果它是全局变量）分配一块连续的内存，足够存储五个 string 类型的指针。每个指针初始值都是 nil。你可以这样赋值：

package main

import "fmt"

func main() {
    var name1, name2 string = "Alice", "Bob"
    var arr [2]*string // 声明一个包含2个*string的数组
    arr[0] = &name1    // 让第一个元素指向name1的地址
    arr[1] = &name2    // 让第二个元素指向name2的地址

    fmt.Printf("arr[0]指向的值: %s\n", *arr[0]) // 输出：Alice
    *arr[0] = "Alicia"                          // 通过指针修改name1的值
    fmt.Printf("name1现在的值: %s\n", name1)     // 输出：Alicia (name1的值被修改了)
}

这里 arr 本身是一个值类型，当它作为函数参数传递时，会发生整个数组的拷贝，包括其内部的指针。然而，拷贝的只是指针本身，这些指针依然指向原始的数据。所以，如果你在函数内部通过 *arr[0] 修改了数据，外部的原始数据也会受影响。

在我看来，指针数组适用于那些你明确知道需要管理固定数量引用，并且这些引用在生命周期内不会频繁增减的场景。比如，一个固定大小的配置项列表，或者一个线程池中固定数量的Worker Goroutine的引用。它提供了一种简洁、内存紧凑的方式来组织这些引用，避免了切片可能带来的额外开销（如扩容时的内存重新分配和数据拷贝）。它的局限性也显而易见：一旦需求变化，需要增减元素，你就得重新定义一个数组，这在动态场景下显得非常笨拙。

Golang中“指针切片”的灵活性与陷阱（[]*T 的应用与考量）

如果说指针数组是固定画框里的艺术品，那么指针切片 []*T 就是一块可以无限延伸的画布。它是一个切片，其元素是指针。这赋予了它无与伦比的灵活性。你可以随时 append 新的指针，也可以 slice 出它的子集，或者利用 copy 函数进行操作。

声明 var users []*User 后，你可以不断地向其中添加 *User 类型的指针：

package main

import "fmt"

type User struct {
    ID   int
    Name string
}

func main() {
    var users []*User // 声明一个*User类型的切片
    user1 := &User{ID: 1, Name: "Charlie"}
    user2 := &User{ID: 2, Name: "David"}

    users = append(users, user1, user2) // 添加用户指针

    fmt.Printf("切片中第一个用户的名字: %s\n", users[0].Name) // 输出：Charlie

    // 修改指针指向的数据
    users[0].Name = "Charles"
    fmt.Printf("user1现在的值: %+v\n", user1)    // 输出：&{ID:1 Name:Charles} (user1的值被修改了)

    // 添加更多用户
    user3 := &User{ID: 3, Name: "Eve"}
    users = append(users, user3)
    fmt.Printf("切片当前的长度: %d\n", len(users))    // 输出：3
}

这种结构在处理动态数据集时简直是如鱼得水。想象一下你正在构建一个Web服务，需要维护一个在线用户列表，用户随时可能上线下线，这时候 []*User 就显得非常自然。

然而，灵活性往往伴随着一些需要注意的“陷阱”。最常见的就是浅拷贝问题。当你将一个 []*T 切片赋值给另一个切片变量时（newSlice := oldSlice），或者将它作为参数传递给函数时，拷贝的只是切片头（指向底层数组的指针、长度和容量）。这意味着两个切片变量现在都指向同一个底层数组。如果你通过 newSlice 修改了底层数组中的某个指针所指向的数据，那么 oldSlice 也能“看到”这个变化。

更深层次的思考是，当切片因为 append 操作而扩容时，它可能会分配一个新的底层数组，并将旧数组的元素（也就是那些指针）拷贝过去。但这些被拷贝的指针，依然指向它们最初指向的数据。这很重要，因为它意味着即使切片本身在内存中“搬家”了，它所“持有”的数据对象并没有搬家，它们还是在原来的位置。

何时选择指针数组，何时偏爱指针切片？（场景驱动的决策）

选择指针数组还是指针切片，这并非一道非黑即白的选择题，更多的是一个权衡利弊、场景驱动的决策。

在我看来，如果你面对的场景是：

1. 数量固定且已知：你明确知道你需要管理多少个对象引用，并且这个数量在程序的整个生命周期中几乎不会改变。比如，一个应用程序启动时加载的固定插件列表，或者一个连接池中固定数量的数据库连接句柄。
2. 对内存布局有严格要求：你可能希望这些指针本身在内存中是连续存放的，并且不希望有切片头带来的额外开销（虽然微乎其微）。
3. 避免意外扩容：你希望确保容器不会在运行时无意中改变大小或重新分配内存。

那么，指针数组 [N]*T 会是一个非常直接且高效的选择。它的语义清晰，性能可预测。

而当你遇到以下情况时，指针切片 []*T 的优势就凸显出来了：

1. 数量动态变化：你需要一个容器来存储对象引用，但这些引用的数量会随着程序的运行而增加或减少，例如用户列表、待处理任务队列、日志条目集合。
2. 灵活操作：你需要频繁地添加、删除、截取或合并引用集合。切片的 append、slice、copy 等操作提供了极大的便利性。
3. **函数间传递和修改容器

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。