Go语言指针修改字符串技巧

本文深入探讨Go语言中通过指针修改字符串值的两种常见操作：`*dest = src` 和 `dest = &src`。我们将详细解析这两种赋值方式的底层机制和作用域影响，阐明为何前者能成功修改原始字符串，而后者仅在函数局部生效，旨在帮助开发者避免常见的指针误用，掌握Go语言中指针的正确使用姿态。

在Go语言中，理解指针的工作原理对于编写高效且无误的代码至关重要，尤其是在需要通过函数修改外部变量值时。字符串作为一种不可变类型，其值的修改通常涉及创建新字符串。然而，当我们通过指针传递字符串时，如何正确地修改指针所指向的字符串变量，常常会引起混淆。本文将通过一个具体的例子，深入剖析 *dest = src 和 dest = &src 这两种看似相似却效果迥异的指针操作。

Go语言中的指针基础

在Go语言中，指针是一个存储另一个变量内存地址的变量。

• & 运算符用于获取变量的内存地址，例如 &a 会返回变量 a 的地址。
• * 运算符用于解引用指针，即访问指针所指向的内存地址中存储的值。例如，如果 p 是一个指向 a 的指针，那么 *p 将会得到 a 的值。

Go语言函数参数传递总是采用值传递（pass-by-value）的方式。这意味着当一个变量作为参数传递给函数时，函数会接收到该变量的一个副本。对于指针类型，传递的是指针本身的副本，而非指针所指向的值的副本。

错误的指针赋值方式：dest = &src

考虑以下函数 changeStringValueNotOK：

func changeStringValueNotOK(dest *string, src string) {
    dest = &src
}

当调用 changeStringValueNotOK(&a, b) 时：

1. dest 接收到的是 &a 的一个副本。此时，函数内部的 dest 和函数外部的 &a 都指向变量 a 的内存地址。
2. src 接收到的是 b 的一个副本，其值为 "World"。
3. 语句 dest = &src 执行时，它将函数内部局部变量 dest 的值修改为 src 变量的内存地址。请注意，这里的 src 是函数内部的一个局部变量，其生命周期仅限于 changeStringValueNotOK 函数的执行期间。
4. 这个操作改变的仅仅是函数内部 dest 这个指针变量自身的值，使其现在指向了局部变量 src。它并没有改变 dest 原来所指向的外部变量 a 的内容，也没有改变函数外部 main 函数中 &a 这个指针的值。
5. 函数执行完毕后，局部变量 dest 的改变以及 src 变量本身都会被销毁，对外部变量 a 没有任何影响。因此，a 的值依然是 "Hello"。

这种方式的本质是修改了函数内部的指针副本，使其指向了另一个内存地址，而原始指针在函数外部仍然指向其最初的内存地址。

正确的指针赋值方式：*dest = src

现在，我们来看正确的做法 changeStringValueOK：

func changeStringValueOK(dest *string, src string) {
    *dest = src
}

当调用 changeStringValueOK(&a, b) 时：

1. dest 同样接收到的是 &a 的一个副本。此时，函数内部的 dest 和函数外部的 &a 都指向变量 a 的内存地址。
2. src 接收到的是 b 的一个副本，其值为 "World"。
3. 语句 *dest = src 执行时：
   • *dest 表示解引用指针 dest，即访问 dest 所指向的内存地址。由于 dest 指向的是外部变量 a 的内存地址，*dest 实际上就是对 a 所占据的内存空间进行操作。
   • = src 表示将 src 的值（"World"）赋给 *dest 所指向的内存位置。
4. 因此，这个操作直接修改了外部变量 a 所存储的值，将其从 "Hello" 变为了 "World"。

这种方式的本质是利用了指针的解引用，直接修改了指针所指向的内存地址中的内容，从而实现了对外部变量的修改。

完整示例代码

为了更好地理解上述概念，请看以下完整的Go程序：

package main

import (
    "fmt"
)

// changeStringValueNotOK 示例错误的指针赋值
// 它会修改函数内部的指针变量dest，使其指向局部变量src的地址
// 但不会影响函数外部的原始变量a
func changeStringValueNotOK(dest *string, src string) {
    fmt.Printf("  [NotOK] dest (inside func, before assignment): %p, points to: %q\n", dest, *dest)
    fmt.Printf("  [NotOK] src (inside func): %p, value: %q\n", &src, src)
    dest = &src // 错误：修改的是局部指针副本，使其指向局部变量src的地址
    fmt.Printf("  [NotOK] dest (inside func, after assignment):  %p, points to: %q\n", dest, *dest)
}

// changeStringValueOK 示例正确的指针赋值
// 它会解引用指针dest，并修改其所指向的内存地址中的值
// 从而影响函数外部的原始变量a
func changeStringValueOK(dest *string, src string) {
    fmt.Printf("  [OK]    dest (inside func, before assignment): %p, points to: %q\n", dest, *dest)
    fmt.Printf("  [OK]    src (inside func): %p, value: %q\n", &src, src)
    *dest = src // 正确：解引用dest，修改其指向的值
    fmt.Printf("  [OK]    dest (inside func, after assignment):  %p, points to: %q\n", dest, *dest)
}

func main() {
    a := "Hello"
    b := "World"

    fmt.Printf("main: Initial a: %q (address: %p)\n", a, &a)
    fmt.Printf("main: Initial b: %q (address: %p)\n", b, &b)
    fmt.Println("--- Calling changeStringValueNotOK ---")
    changeStringValueNotOK(&a, b)
    fmt.Printf("main: After changeStringValueNotOK, a: %q (address: %p)\n", a, &a) // 仍然是 "Hello"
    fmt.Println("--- Calling changeStringValueOK ---")
    changeStringValueOK(&a, b)
    fmt.Printf("main: After changeStringValueOK, a: %q (address: %p)\n", a, &a)   // 现在是 "World"
}

运行上述代码，你将看到清晰的输出，展示 a 的值在 changeStringValueNotOK 调用后未变，而在 changeStringValueOK 调用后成功改变。额外添加的 Printf 语句可以帮助你观察函数内部指针变量 dest 和 src 的地址变化。

注意事项与总结

1. 值传递的本质：Go语言中所有参数传递都是值传递。即使是传递指针，传递的也是指针变量本身的副本。
2. 区分指针赋值与解引用赋值：
   • dest = &src：将指针变量 dest 重新赋值，使其指向 src 的地址。如果 dest 是函数参数，则此修改仅在函数内部的 dest 副本上生效，不影响外部传入的原始指针或其指向的值。
   • *dest = src：解引用指针 dest，访问它所指向的内存位置，并将 src 的值赋给该位置。这会直接修改外部变量的值。
3. 局部变量的生命周期：当 dest = &src 时，如果 src 是函数内部的局部变量，那么 dest 指向的地址在函数返回后将变得无效，这可能导致悬空指针（dangling pointer）问题，尽管在Go中由于垃圾回收机制这通常不是直接的内存安全问题，但逻辑上是错误的。
4. 何时使用：
   • 如果你希望函数修改调用者提供的变量值，请使用 *dest = value。
   • 如果你希望函数修改调用者提供的指针本身（例如，让一个外部指针指向一个新的对象），你需要传递一个指向指针的指针（**Type），这在Go中相对不常见，通常通过函数返回新指针来实现。

理解 *dest = src 和 dest = &src 之间的微妙差异是掌握Go语言指针操作的关键。前者用于修改指针所指向的值，而后者用于修改指针变量自身的值。在大多数需要通过函数修改外部变量的场景中，我们都应该使用解引用赋值 *dest = value。正确地运用这些概念，将使你的Go程序更加健壮和可预测。