Go语言方法接收器选择：值类型与指针类型的实践指南

package main

import "fmt"

type Counter struct {
    value int
}

// 指针接收器方法：可以修改接收器实例的value字段
func (c *Counter) IncrementPointer() {
    c.value++
}

// 值接收器方法：操作的是接收器的一个副本，无法修改原始接收器
func (c Counter) IncrementValue() {
    c.value++
}

func main() {
    myCounter := Counter{value: 0}

    fmt.Printf("初始值: %d\n", myCounter.value) // 0

    myCounter.IncrementPointer()
    fmt.Printf("调用 IncrementPointer() 后: %d\n", myCounter.value) // 1 (原始值被修改)

    myCounter.IncrementValue()
    fmt.Printf("调用 IncrementValue() 后: %d\n", myCounter.value) // 1 (原始值未改变)

    // 验证 IncrementValue 确实修改了副本
    anotherCounter := Counter{value: 10}
    fmt.Printf("另一个计数器初始值: %d\n", anotherCounter.value) // 10
    anotherCounterCopy := anotherCounter // 显式复制
    anotherCounterCopy.IncrementValue()
    fmt.Printf("另一个计数器调用 IncrementValue() 后 (原始): %d\n", anotherCounter.value)     // 10
    fmt.Printf("另一个计数器调用 IncrementValue() 后 (副本): %d\n", anotherCounterCopy.value) // 11
}

package main

import (
    "fmt"
    "runtime"
    "time"
)

// 定义一个大型结构体，模拟占用较大内存
type LargeStruct struct {
    data [1024 * 1024]byte // 1MB 数据
    id   int
    name string
}

// 值接收器方法
func (ls LargeStruct) ProcessValue() {
    // 模拟一些操作
    _ = ls.id
}

// 指针接收器方法
func (ls *LargeStruct) ProcessPointer() {
    // 模拟一些操作
    _ = ls.id
}

func main() {
    largeObj := LargeStruct{id: 1, name: "test"}

    // 测量值接收器方法性能
    start := time.Now()
    for i := 0; i < 100; i++ {
        largeObj.ProcessValue()
    }
    fmt.Printf("值接收器方法（复制大对象）耗时: %v\n", time.Since(start))

    // 测量指针接收器方法性能
    start = time.Now()
    for i := 0; i < 100; i++ {
        largeObj.ProcessPointer()
    }
    fmt.Printf("指针接收器方法（传递指针）耗时: %v\n", time.Since(start))

    // 观察内存使用情况（仅作示意，精确测量需借助pprof等工具）
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("当前堆内存分配: %v MB\n", m.Alloc/1024/1024)
}

package main

import "fmt"

type MyType struct {
    data int
}

// 必须使用指针接收器来修改data
func (m *MyType) SetData(d int) {
    m.data = d
}

// 即使此方法不修改data，也建议使用指针接收器以保持一致性
func (m *MyType) GetData() int {
    return m.data
}

func main() {
    val := MyType{data: 10}
    ptr := &MyType{data: 20}

    // 对于值类型变量，如果 GetData() 是值接收器，SetData() 是指针接收器，
    // 那么 val.SetData(15) 将无法编译通过，因为 val 的方法集不包含 SetData。
    // 但如果 GetData() 也是指针接收器，则 val.GetData() 会自动转换为 (&val).GetData()
    // 从而使两者都可以被调用。
    fmt.Printf("val 初始数据: %d\n", val.GetData()) // 输出 10
    val.SetData(15) // 编译器会自动将 val 转换为 &val
    fmt.Printf("val 修改后数据: %d\n", val.GetData()) // 输出 15

    fmt.Printf("ptr 初始数据: %d\n", ptr.GetData()) // 输出 20
    ptr.SetData(25)
    fmt.Printf("ptr 修改后数据: %d\n", ptr.GetData()) // 输出 25
}

package main

import (
    "fmt"
    "math"
    "sync"
)

type Point struct {
    X, Y int
}

// 值接收器方法，计算点到原点的距离，不修改Point本身
func (p Point) DistanceToOrigin() float64 {
    return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}

func main() {
    p1 := Point{X: 3, Y: 4}
    p2 := Point{X: 5, Y: 12}

    var wg sync.WaitGroup
    wg.Add(2)

    // 这个方法可以安全地在多个goroutine中调用，因为它不修改Point实例
    go func() {
        defer wg.Done()
        fmt.Printf("点 (%d,%d) 到原点距离: %.2f\n", p1.X, p1.Y, p1.DistanceToOrigin())
    }()

    go func() {
        defer wg.Done()
        fmt.Printf("点 (%d,%d) 到原点距离: %.2f\n", p2.X, p2.Y, p2.DistanceToOrigin())
    }()

    wg.Wait()
}