指针数组是固定大小的指针容器，内存连续且不可变；指针切片是动态可变的指针集合，支持灵活扩容与操作，适用于数量不确定的场景。
在Golang的世界里，指针是绕不开的话题，而当指针与数组、切片这两种数据结构结合时，很多初学者，甚至一些有经验的开发者，都会感到一丝困惑。究其核心，”指针数组”（
[N]*T
）和”指针切片”（
[]*T
）之间的区别，可以概括为：前者是一个固定大小的容器，其每个槽位都存放着一个指向特定类型数据的指针；而后者则是一个动态可变的容器，它的每个元素同样是指针，但其自身的长度和容量可以根据需求灵活调整。理解它们，关键在于把握“固定与动态”、“容器本身”与“容器元素”这两个维度。
解决方案
要深入理解这两种结构，我们不妨从它们的声明、内存布局以及实际操作的层面进行剖析。指针数组，顾名思义，它首先是一个数组。这意味着一旦你声明了
var arr [3]*int
，你就拥有了一个包含三个
*int
类型元素的数组，这个数组的大小是固定的，不可更改。这三个
*int
元素各自可以指向一个整数值，或者保持为
nil
。它的内存分配是连续的，所有指针本身存储在一起。
相比之下，指针切片
[]*T
则展现出截然不同的动态性。它是一个切片，这意味着它拥有一个指向底层数组的指针、一个长度（len）和一个容量（cap）。当声明
var s []*int
时，你得到的是一个初始为空的切片。你可以通过
append
操作向其中添加
*int
类型的元素，切片会根据需要自动扩容，其底层数组可能会在内存中重新分配。这里的每个元素同样是一个
*int
，指向某个整数值。
所以，最直观的区别就是：数组的“骨架”是死的，切片的“骨架”是活的。但无论是哪种，它们内部存储的都是指针，这些指针才指向真正的数据。这带来一个有趣的现象：即使切片本身重新分配了底层数组，其内部的指针依然指向最初的那些数据，除非你显式地修改这些指针所指向的内容。
立即学习“go语言免费学习笔记（深入）”；
Golang中“指针数组”究竟意味着什么？（[N]*T 的深层解析）
说起指针数组，我总觉得它带有一种古典的、固定的美感。
[N]*T
这种结构，本质上是一个类型为
T
的指针的数组。这意味着，这个数组的每一个“格子”里，都老老实实地放着一个指向
T
类型数据的地址。它的固定性是其最显著的特征：一旦定义，其大小
N
就被焊死了，不能增也不能减。
从内存层面看，当你声明
var arr [5]*string
时，Go 会在栈上（如果它是一个局部变量）或者静态存储区（如果它是全局变量）分配一块连续的内存，足够存储五个
string
类型的指针。每个指针初始值都是
nil
。你可以这样赋值：
package mainimport "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]指向的值: %sn", *arr[0]) // 输出：Alice *arr[0] = "Alicia" // 通过指针修改name1的值 fmt.Printf("name1现在的值: %sn", name1) // 输出：Alicia (name1的值被修改了)}
这里
arr
本身是一个值类型，当它作为函数参数传递时，会发生整个数组的拷贝，包括其内部的指针。然而，拷贝的只是指针本身，这些指针依然指向原始的数据。所以，如果你在函数内部通过
*arr[0]
修改了数据，外部的原始数据也会受影响。
在我看来，指针数组适用于那些你明确知道需要管理固定数量引用，并且这些引用在生命周期内不会频繁增减的场景。比如，一个固定大小的配置项列表，或者一个线程池中固定数量的Worker Goroutine的引用。它提供了一种简洁、内存紧凑的方式来组织这些引用，避免了切片可能带来的额外开销（如扩容时的内存重新分配和数据拷贝）。它的局限性也显而易见：一旦需求变化，需要增减元素，你就得重新定义一个数组，这在动态场景下显得非常笨拙。
Golang中“指针切片”的灵活性与陷阱（[]*T 的应用与考量）
如果说指针数组是固定画框里的艺术品，那么指针切片
[]*T
就是一块可以无限延伸的画布。它是一个切片，其元素是指针。这赋予了它无与伦比的灵活性。你可以随时
append
新的指针，也可以
slice
出它的子集，或者利用
copy
函数进行操作。
声明
var users []*User
后，你可以不断地向其中添加
*User
类型的指针：
package mainimport "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("切片中第一个用户的名字: %sn", users[0].Name) // 输出：Charlie // 修改指针指向的数据 users[0].Name = "Charles" fmt.Printf("user1现在的值: %+vn", user1) // 输出：&{ID:1 Name:Charles} (user1的值被修改了) // 添加更多用户 user3 := &User{ID: 3, Name: "Eve"} users = append(users, user3) fmt.Printf("切片当前的长度: %dn", len(users)) // 输出：3}
这种结构在处理动态数据集时简直是如鱼得水。想象一下你正在构建一个Web服务，需要维护一个在线用户列表，用户随时可能上线下线，这时候
[]*User
就显得非常自然。
然而，灵活性往往伴随着一些需要注意的“陷阱”。最常见的就是浅拷贝问题。当你将一个
[]*T
切片赋值给另一个切片变量时（
newSlice := oldSlice
），或者将它作为参数传递给函数时，拷贝的只是切片头（指向底层数组的指针、长度和容量）。这意味着两个切片变量现在都指向同一个底层数组。如果你通过
newSlice
修改了底层数组中的某个指针所指向的数据，那么
oldSlice
也能“看到”这个变化。
更深层次的思考是，当切片因为
append
操作而扩容时，它可能会分配一个新的底层数组，并将旧数组的元素（也就是那些指针）拷贝过去。但这些被拷贝的指针，依然指向它们最初指向的数据。这很重要，因为它意味着即使切片本身在内存中“搬家”了，它所“持有”的数据对象并没有搬家，它们还是在原来的位置。
何时选择指针数组，何时偏爱指针切片？（场景驱动的决策）
选择指针数组还是指针切片，这并非一道非黑即白的选择题，更多的是一个权衡利弊、场景驱动的决策。
在我看来，如果你面对的场景是：
数量固定且已知：你明确知道你需要管理多少个对象引用，并且这个数量在程序的整个生命周期中几乎不会改变。比如，一个应用程序启动时加载的固定插件列表，或者一个连接池中固定数量的数据库连接句柄。对内存布局有严格要求：你可能希望这些指针本身在内存中是连续存放的，并且不希望有切片头带来的额外开销（虽然微乎其微）。避免意外扩容：你希望确保容器不会在运行时无意中改变大小或重新分配内存。
那么，指针数组
[N]*T
会是一个非常直接且高效的选择。它的语义清晰，性能可预测。
而当你遇到以下情况时，指针切片
[]*T
的优势就凸显出来了：
数量动态变化：你需要一个容器来存储对象引用，但这些引用的数量会随着程序的运行而增加或减少，例如用户列表、待处理任务队列、日志条目集合。灵活操作：你需要频繁地添加、删除、截取或合并引用集合。切片的
append
、
slice
、
copy
等操作提供了极大的便利性。**函数间传递和修改容器
以上就是Golang指针数组与指针切片区别与使用的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1402767.html
微信扫一扫 
支付宝扫一扫 
