Go语言学习笔记23：结构体指针

一、结构体指针的定义与初始化

1. 声明结构体指针

type Person struct {
    Name string
    Age  int
}

// 声明指针变量
var p1 *Person          // 初始值为nil
p2 := new(Person)       // 使用new分配内存，初始化为零值
p3 := &Person{"Alice", 30} // 通过字面量初始化
p4 := &Person{          // 带字段名的初始化（推荐）
    Name: "Bob",
    Age:  25,
}

2. 指针的零值

未初始化的结构体指针默认值为nil，直接访问会导致运行时错误：

var p *Person
fmt.Println(p.Name) // panic: nil pointer dereference

二、结构体指针的访问与操作

1. 访问字段

Go语言简化了指针访问字段的语法，无需显式解引用：

p := &Person{"Charlie", 28}
fmt.Println(p.Name) // 自动转换为(*p).Name
p.Age = 29          // 直接修改字段

2. 作为函数参数

传递指针避免结构体复制，尤其适用于大型结构体：

func UpdateName(p *Person, newName string) {
    p.Name = newName
}

// 调用
person := &Person{"Dave", 35}
UpdateName(person, "David")

三、指针接收者（Pointer Receiver）

1. 定义指针接收者方法

方法需要修改结构体内容时，必须使用指针接收者：

func (p *Person) SetAge(newAge int) {
    p.Age = newAge
}

2. 自动转换规则

Go编译器自动处理值和指针的转换，使调用更灵活：

pVal := Person{"Eve", 40}
pPtr := &pVal

pVal.SetAge(41)  // 编译器转换为(&pVal).SetAge(41)
pPtr.SetAge(42)  // 直接使用指针调用

fmt.Println(pVal.Age) // 输出42

四、性能与使用场景

1. 性能对比

2. 适用场景

• 必须用指针：需要修改原结构体内容时
• 推荐用指针：传递大型结构体时（如包含数组或嵌套结构）
• 可用值类型：不可变结构体或小型结构体

五、指针与接口的关系

1. 接口实现规则

• 若方法使用指针接收者，只有结构体指针实现接口
• 若方法使用值接收者，值类型和指针类型均实现接口

type Stringer interface {
    String() string
}

// 指针接收者实现接口
func (p *Person) String() string {
    return fmt.Sprintf("%s (%d)", p.Name, p.Age)
}

func main() {
    var s Stringer
    p := Person{"Frank", 50}

    s = &p // 正确
    // s = p  // 编译错误：Person未实现Stringer
}

六、常见错误与规避

1. 空指针解引用

错误示例：

var p *Person
p.Name = "Grace" // panic: nil pointer

正确做法：

p := new(Person) // 或 &Person{}
p.Name = "Grace"

2. 意外的数据共享

type Team struct {
    Leader *Person
}

p := &Person{"Hank", 45}
team1 := Team{p}
team2 := Team{p}

team1.Leader.Age = 50
fmt.Println(team2.Leader.Age) // 输出50（共享同一指针）

七、最佳实践总结

八、综合示例

package main

import (
    "fmt"
    "sync"
)

type Counter struct {
    sync.Mutex
    count int
}

func (c *Counter) Increment() {
    c.Lock()
    defer c.Unlock()
    c.count++
}

func (c *Counter) Value() int {
    return c.count
}

func main() {
    counter := &Counter{}

    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            counter.Increment()
            wg.Done()
        }()
    }

    wg.Wait()
    fmt.Println("Final count:", counter.Value()) // 正确输出1000
}

关键点：
– 使用指针接收者确保修改原结构体
– 通过sync.Mutex保证并发安全
– 指针传递避免结构体复制

总结

结构体指针在Go语言中提供了以下核心优势：
1. 高效内存管理：减少大型结构体的复制开销
2. 直接数据修改：通过指针接收者改变原结构体状态
3. 灵活接口实现：控制类型与接口的匹配关系
4. 资源共享能力：多个指针指向同一内存区域