Golang指针数组与指针切片区别与使用

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

在Golang的世界里，指针是绕不开的话题，而当指针与数组、切片这两种数据结构结合时，很多初学者，甚至一些有经验的开发者，都会感到一丝困惑。究其核心，"指针数组"（

[N]*T

[]*T

解决方案

要深入理解这两种结构，我们不妨从它们的声明、内存布局以及实际操作的层面进行剖析。指针数组，顾名思义，它首先是一个数组。这意味着一旦你声明了

var arr [3]*int

*int

*int

nil

相比之下，指针切片

[]*T

var s []*int

append

*int

*int

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

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

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

说起指针数组，我总觉得它带有一种古典的、固定的美感。

[N]*T

T

T

N

从内存层面看，当你声明

var arr [5]*string

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

Cardify卡片工坊

使用Markdown一键生成精美的小红书知识卡片

41

查看详情

声明

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指针数组与指针切片区别与使用的详细内容，更多请关注php中文网其它相关文章！