Go语言中所有参数传递均为按值传递，传递指针时实际传递的是指针副本，但副本仍指向同一内存地址，从而可修改原始变量。
在Go语言中，当你将一个变量作为函数参数传递时，默认行为是“按值传递”（pass by value）。这意味着函数接收到的是原始变量的一个副本。如果函数内部修改了这个副本，原始变量并不会受到影响。然而，如果你希望函数能够修改传入的原始变量，那么你需要传递该变量的“指针”。指针本质上是一个内存地址，它指向了原始变量在内存中的位置，这样函数就可以通过这个地址直接操作原始数据。
理解Go语言中指针传递函数参数的关键在于把握其“按值传递”的哲学。Go语言中，所有的参数传递都是按值传递。即使是传递一个指针，你传递的也是这个指针变量本身的一个副本，只不过这个副本存储的是同一个内存地址。
让我们通过代码示例来具体说明：
package main
import "fmt"
// changeValue 接收一个 int 类型的值。
// 它修改的是传入参数的副本，不会影响原始变量。
func changeValue(num int) {
num = 100 // 这里的修改只作用于 num 的副本
fmt.Printf("在 changeValue 函数内部：num 的地址是 %p，值是 %d\n", &num, num)
}
// changePointer 接收一个 *int 类型的值（一个指向 int 的指针）。
// 通过解引用指针，它可以修改指针所指向的原始变量。
func changePointer(ptr *int) {
if ptr == nil {
fmt.Println("传入了一个空指针，无法修改。")
return
}
*ptr = 200 // 解引用指针并修改其指向的值
fmt.Printf("在 changePointer 函数内部：ptr 指向的地址是 %p，值是 %d\n", ptr, *ptr)
}
// changeStructValue 接收一个 Person 结构体的值。
// 它修改的是结构体的副本。
type Person struct {
Name string
Age int
}
func changeStructValue(p Person) {
p.Age = 30 // 修改副本的 Age 字段
fmt.Printf("在 changeStructValue 内部：Person 的地址 %p，Age %d\n", &p, p.Age)
}
// changeStructPointer 接收一个 *Person 类型的值（一个指向 Person 的指针）。
// 它可以通过指针修改原始结构体的字段。
func changeStructPointer(p *Person) {
if p == nil {
fmt.Println("传入了一个空指针，无法修改。")
return
}
p.Age = 40 // 通过指针修改原始结构体的 Age 字段
fmt.Printf("在 changeStructPointer 内部：Person 指向的地址 %p，Age %d\n", p, p.Age)
}
func main() {
// 示例 1: 基本类型 int
myInt := 10
fmt.Printf("调用 changeValue 前：myInt 的地址是 %p，值是 %d\n", &myInt, myInt)
changeValue(myInt)
fmt.Printf("调用 changeValue 后：myInt 的地址是 %p，值是 %d\n", &myInt, myInt) // myInt 仍然是 10
fmt.Println("------------------------------------")
// 示例 2: 使用指针修改基本类型 int
fmt.Printf("调用 changePointer 前：myInt 的地址是 %p，值是 %d\n", &myInt, myInt)
changePointer(&myInt) // 传入 myInt 的地址
fmt.Printf("调用 changePointer 后：myInt 的地址是 %p，值是 %d\n", &myInt, myInt) // myInt 现在是 200
fmt.Println("------------------------------------")
// 示例 3: 结构体类型
person := Person{Name: "Alice", Age: 25}
fmt.Printf("调用 changeStructValue 前：Person 的地址 %p，Age %d\n", &person, person.Age)
changeStructValue(person)
fmt.Printf("调用 changeStructValue 后：Person 的地址 %p，Age %d\n", &person, person.Age) // person.Age 仍然是 25
fmt.Println("------------------------------------")
// 示例 4: 使用指针修改结构体类型
fmt.Printf("调用 changeStructPointer 前：Person 的地址 %p，Age %d\n", &person, person.Age)
changeStructPointer(&person) // 传入 person 结构体的地址
fmt.Printf("调用 changeStructPointer 后：Person 的地址 %p，Age %d\n", &person, person.Age) // person.Age 现在是 40
}运行上述代码，你会清晰地看到，只有当我们将变量的地址（指针）传递给函数时，函数才能真正地修改原始变量的值。这是Go语言中实现函数副作用（修改外部状态）的核心机制之一。
立即学习“go语言免费学习笔记（深入）”；
这确实是一个Go开发者经常需要权衡的问题。我个人认为，决定是否传递指针参数，主要取决于几个核心考量：
IncrementCounter(count *int)
UpdateUserDetails(user *User, newDetails map[string]string)
func (p MyType) MyMethod()
func (p *MyType) MyMethod()
*string
nil
if param != nil
总的来说，我倾向于在需要修改数据或处理大型数据结构时使用指针。对于小型、简单的值类型（如
int
bool
string
尽管指针传递在Go语言中非常强大且不可或缺，但它也伴随着一些需要注意的陷阱。作为一个实际的开发者，我在这方面吃过不少亏，所以总结了一些经验：
空指针（nil pointer）解引用： 这是最常见、也最致命的错误之一。如果你接收到一个指针参数，但在使用它之前没有检查它是否为
nil
nil
*ptr
func processData(data *MyData) {
// ❌ 危险！如果 data 是 nil，这里会 panic
// data.SomeField = "new value"
// ✅ 最佳实践：在使用前进行 nil 检查
if data == nil {
fmt.Println("警告：传入了一个空数据指针，操作被跳过。")
return
}
data.SomeField = "new value"
}养成在函数入口处进行
nil
nil
意外的副作用和可变性： 指针传递的本质是允许函数修改外部状态。如果滥用，或者函数文档不清晰，这可能导致代码变得难以理解和维护。一个函数可能会在不经意间修改了调用者期望保持不变的数据，从而引入难以追踪的bug。 最佳实践：
MutateConfig
ReadConfig
并发问题（竞态条件）： 当多个goroutine同时持有同一个数据的指针，并且至少有一个goroutine尝试修改该数据时，就会发生竞态条件（race condition）。这会导致不可预测的结果，并且通常很难调试。 最佳实践：
sync.Mutex
sync.Mutex
生命周期和悬空指针： Go语言有垃圾回收机制，这大大减轻了手动管理内存的负担，通常不会出现C/C++中的“悬空指针”问题（即指针指向的内存已经被释放）。然而，在某些特殊场景，比如与C语言代码通过
cgo
过度使用指针： 有时候，我会看到一些代码为了“看起来更像C++”或者“避免复制”，即使对于很小的结构体或基本类型也传递指针。这反而可能让代码变得更复杂，因为你需要处理
nil
Go语言在类型系统上，常常会引起一些初学者的困惑，因为它不像C++那样有明确的“引用类型”概念，也不像Java那样将所有对象都视为引用。在我看来，理解Go的关键在于：Go语言中所有的数据传递都是按值传递。 所谓的“引用类型”在Go中，更多是指那些其底层数据结构本身包含指针的类型，但这些类型在传递时，传递的仍然是它们“值”的副本。
让我们来剖析一下：
纯值类型：
int
float64
bool
string
array
struct
var a int = 10
fmt.Printf("%p\n", &a)a
a
func(x int)
x
a
“引用语义”类型（但本质仍是值类型）：
slice
map
channel
function
ptr
len
cap
ptr
s[0] = 100
s = append(s, 1)
*指针 `T`：**
*T
*T
*ptr
ptr = &anotherVar
总结来说： Go语言中没有传统意义上的“引用类型”这个概念来区分对象和基本类型。所有变量，包括slice、map、channel，在传递时都是按值传递。只不过，slice、map等类型的值恰好是一个包含指针的结构体。而显式的指针
*T
以上就是Golang指针传递函数参数示例的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
424
收藏
