Go 语言新手扫盲：指针 * 和 & 使用场景详解

北冥you鱼2026-07-25 12:09

引言：为什么 Go 语言需要指针？

在 Go 语言中，指针是一个让许多初学者感到困惑但又至关重要的概念。与 Python、Java 等语言不同，Go 保留了显式的指针操作，这既带来了性能优势，也增加了代码的灵活性。本文将深入浅出地讲解 Go 语言中指针符号 * 和 & 的核心概念、使用场景以及最佳实践，帮助你彻底掌握这一重要特性。

1. 指针基础：理解 * 和 & 的含义

1.1 什么是指针？

指针是一个变量，其值为另一个变量的内存地址。在 Go 中，每个变量都存储在内存的某个位置，指针就是指向这个位置的"路标"。

1.2 两个关键符号

  • &（取地址符）：获取变量的内存地址
  • *（解引用符）：通过指针访问或修改其指向的值
go 复制代码 
package main

import "fmt"

func main() {
    var num int = 42
    var ptr *int  // 声明一个指向 int 类型的指针
    
    ptr = &num    // & 获取 num 的内存地址，赋值给 ptr
    fmt.Println("变量 num 的值:", num)        // 输出: 42
    fmt.Println("变量 num 的地址:", &num)     // 输出: 0xc00001a0a0
    fmt.Println("指针 ptr 的值:", ptr)        // 输出: 0xc00001a0a0
    fmt.Println("指针 ptr 指向的值:", *ptr)   // * 解引用，输出: 42
    
    *ptr = 100    // 通过指针修改原变量的值
    fmt.Println("修改后 num 的值:", num)      // 输出: 100
}

2. 指针的核心使用场景

2.1 场景一：函数参数传递（避免值拷贝）

当需要修改函数外部的变量，或者传递大型结构体时，使用指针可以避免昂贵的值拷贝。

go 复制代码 
package main

import "fmt"

// 值传递：无法修改原值
func modifyByValue(x int) {
    x = x * 2
    fmt.Println("函数内 x:", x)  // 输出: 20
}

// 指针传递：可以修改原值
func modifyByPointer(x *int) {
    *x = *x * 2
    fmt.Println("函数内 *x:", *x)  // 输出: 20
}

func main() {
    value := 10
    
    modifyByValue(value)
    fmt.Println("值传递后 value:", value)  // 输出: 10（未改变）
    
    modifyByPointer(&value)
    fmt.Println("指针传递后 value:", value)  // 输出: 20（已改变）
}

2.2 场景二：操作大型结构体

对于包含多个字段的结构体，使用指针可以显著提升性能。

go 复制代码 
package main

import "fmt"

type User struct {
    ID       int
    Name     string
    Email    string
    Age      int
    Address  string
    // ... 更多字段
}

// 值传递：复制整个结构体（性能差）
func processUserByValue(u User) {
    u.Name = "Modified"
    // 处理逻辑...
}

// 指针传递：只传递地址（性能好）
func processUserByPointer(u *User) {
    u.Name = "Modified"
    // 处理逻辑...
}

func main() {
    user := User{
        ID:    1,
        Name:  "Alice",
        Email: "alice@example.com",
        Age:   30,
    }
    
    // 值传递：复制约 100+ 字节
    processUserByValue(user)
    
    // 指针传递：只复制 8 字节（64位系统）
    processUserByPointer(&user)
}

2.3 场景三：实现方法接收者

在 Go 中，可以为类型定义方法，接收者可以是值类型或指针类型，这决定了方法是否能修改接收者。

go 复制代码 
package main

import "fmt"

type Counter struct {
    count int
}

// 值接收者：无法修改原结构体
func (c Counter) IncrementByValue() {
    c.count++
    fmt.Println("值接收者方法内:", c.count)
}

// 指针接收者：可以修改原结构体
func (c *Counter) IncrementByPointer() {
    c.count++
    fmt.Println("指针接收者方法内:", c.count)
}

func main() {
    counter := Counter{count: 0}
    
    counter.IncrementByValue()
    fmt.Println("值接收者调用后:", counter.count)  // 输出: 0
    
    counter.IncrementByPointer()
    fmt.Println("指针接收者调用后:", counter.count)  // 输出: 1
}

2.4 场景四：处理 nil 和零值

指针可以表示"无值"状态（nil），这在某些场景下比零值更有意义。

go 复制代码 
package main

import "fmt"

type Config struct {
    Timeout int
    Retries int
}

func loadConfig() *Config {
    // 模拟配置加载失败
    return nil
}

func main() {
    var config *Config
    
    // 使用 nil 检查比零值检查更明确
    if config == nil {
        fmt.Println("配置未初始化")
    }
    
    config = loadConfig()
    if config == nil {
        fmt.Println("配置加载失败，使用默认值")
        // 初始化默认配置
        config = &Config{Timeout: 30, Retries: 3}
    }
    
    fmt.Printf("配置: %+v\n", config)
}

3. 指针的常见陷阱与解决方案

3.1 空指针解引用

go 复制代码 
package main

import "fmt"

func main() {
    var ptr *int
    fmt.Println(*ptr)  // 运行时 panic: nil pointer dereference
}

解决方案：始终检查指针是否为 nil

go 复制代码 
func safeDereference(ptr *int) int {
    if ptr != nil {
        return *ptr
    }
    return 0  // 或返回合适的默认值
}

3.2 返回局部变量的地址

go 复制代码 
func createLocalPointer() *int {
    x := 10
    return &x  // 危险：x 是局部变量
}

解决方案：使用 new() 或返回值的指针

go 复制代码 
// 正确做法1：使用 new()
func createPointer1() *int {
    return new(int)  // 在堆上分配
}

// 正确做法2：返回结构体指针
type MyStruct struct {
    Value int
}

func createPointer2() *MyStruct {
    return &MyStruct{Value: 10}  // Go 会自动逃逸分析
}

3.3 指针与切片的区别

go 复制代码 
package main

import "fmt"

func main() {
    // 切片本身是引用类型（底层包含指针）
    slice := []int{1, 2, 3}
    modifySlice(slice)
    fmt.Println(slice)  // 输出: [100 2 3]
    
    // 数组需要显式指针
    arr := [3]int{1, 2, 3}
    modifyArray(&arr)
    fmt.Println(arr)    // 输出: [100 2 3]
}

func modifySlice(s []int) {
    if len(s) > 0 {
        s[0] = 100
    }
}

func modifyArray(arr *[3]int) {
    if arr != nil {
        arr[0] = 100  // 注意：这里不需要 *arr[0]
    }
}

4. 高级指针技巧

4.1 指针的指针（**T）

go 复制代码 
package main

import "fmt"

func main() {
    value := 42
    ptr := &value
    pptr := &ptr  // 指向指针的指针
    
    fmt.Println("value:", value)           // 42
    fmt.Println("*ptr:", *ptr)             // 42
    fmt.Println("**pptr:", **pptr)         // 42
    
    **pptr = 100  // 通过双重指针修改原值
    fmt.Println("修改后 value:", value)    // 100
}

4.2 unsafe.Pointer 的使用

go 复制代码 
package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var num int64 = 42
    
    // 将 int64 指针转换为 int32 指针
    ptr := unsafe.Pointer(&num)
    int32Ptr := (*int32)(ptr)
    
    fmt.Printf("原始值: %d\n", num)                // 42
    fmt.Printf("转换后: %d\n", *int32Ptr)          // 42（但只读取前4字节）
    
    // 注意：unsafe 操作需要谨慎，可能引发未定义行为
}

5. 最佳实践总结

5.1 何时使用指针？

  1. 需要修改函数外部变量时
  2. 传递大型结构体或数组时（避免拷贝开销）
  3. 实现需要修改接收者的方法时
  4. 需要表示可选值（nil）时
  5. 与 C 语言库交互时

5.2 何时避免指针？

  1. 小型基本类型（int, float, bool 等）
  2. 不需要修改的切片和映射（它们已经是引用类型）
  3. 简单的值语义场景
  4. 并发安全考虑（指针可能引发数据竞争）

5.3 代码风格建议

go 复制代码 
// 好的写法
func ProcessUser(u *User) error {
    if u == nil {
        return errors.New("user is nil")
    }
    // 处理逻辑
    return nil
}

// 避免过度使用指针
func Add(a, b int) int {
    return a + b  // 不需要指针，简单值类型
}

// 结构体方法根据需求选择接收者类型
type Calculator struct {
    result int
}

// 需要修改接收者
func (c *Calculator) Add(x int) {
    c.result += x
}

// 不需要修改接收者
func (c Calculator) GetResult() int {
    return c.result
}

6. 实战练习

练习1：实现一个简单的链表

go 复制代码 
package main

import "fmt"

type Node struct {
    Value int
    Next  *Node  // 指针指向下一个节点
}

func main() {
    // 创建链表: 1 -> 2 -> 3
    head := &Node{Value: 1}
    second := &Node{Value: 2}
    third := &Node{Value: 3}
    
    head.Next = second
    second.Next = third
    
    // 遍历链表
    current := head
    for current != nil {
        fmt.Printf("%d -> ", current.Value)
        current = current.Next
    }
    fmt.Println("nil")
}

练习2：交换两个变量的值

go 复制代码 
package main

import "fmt"

// 使用指针交换两个变量的值
func swap(a, b *int) {
    temp := *a
    *a = *b
    *b = temp
}

func main() {
    x, y := 10, 20
    fmt.Printf("交换前: x=%d, y=%d\n", x, y)  // x=10, y=20
    
    swap(&x, &y)
    fmt.Printf("交换后: x=%d, y=%d\n", x, y)  // x=20, y=10
}

结语

指针是 Go 语言中一个强大而灵活的特性。虽然初学时会有些挑战，但一旦掌握，你将能够编写出更高效、更优雅的 Go 代码。记住关键原则：使用指针是为了共享数据，而不是复制数据。在实际开发中，根据具体需求谨慎选择值传递还是指针传递，并始终注意空指针检查。

通过本文的学习，你应该已经掌握了 * 和 & 的核心用法。现在，尝试在自己的项目中应用这些知识，从简单的场景开始，逐步深入，最终你会发现自己能够自如地驾驭 Go 语言的指针特性。

相关推荐
shylyly_2 小时前
C++中的类型转换
开发语言·c++·匿名对象·隐式类型转换·拷贝优化
你驴我2 小时前
WhatsApp 消息撤回与编辑的幂等性设计实践
java·服务器·前端·后端·python
一缕清烟在人间2 小时前
HarmonyOS开发实战：小分享-TextEditPage文字编辑器——Header+TextArea+工具栏
后端·华为·harmonyos·鸿蒙
程序员cxuan2 小时前
Opus 5 深夜炸场，价格还挺香。。。
人工智能·后端·程序员
cui_ruicheng2 小时前
Python数据分析（一）：数据分析概述与环境搭建
开发语言·python·数据分析
青山木2 小时前
Hot 100 ---腐烂的橘子
java·数据结构·后端·算法·leetcode·广度优先
卷无止境2 小时前
Python的collections模块：那些被低估的"瑞士军刀"
后端·python
心平气和量大福大2 小时前
C#-WPF-UserControl-生命周期（加载 退出）
开发语言·c#·wpf
卷无止境2 小时前
Python的方法解析顺序：一场关于继承顺序的精妙设计
后端·python
热门推荐
01GitHub 镜像站点02如何新建文件夹？ 电脑新建文件夹的4种方法032026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片04AI科技热点日报 | 2026年07月01日05国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）06AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路07幻兽帕鲁 - 服务器管理员权限与 GM 命令完全指南08微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新092026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？10【解构】DeepSeek V4 发布：技术报告深度解读 + 横向对比六大开源模型，我们的判断是……