深入理解Go语言中的指针与方法接收器

package main

import (
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

// 值接收器方法：不修改接收器，操作的是副本
func (v Vertex) AbsValue() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// 指针接收器方法：可以修改接收器，操作的是原始数据
func (v *Vertex) AbsPointer() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// 示例：一个修改接收器的方法
func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

func main() {
    vValue := Vertex{3, 4}
    vPointer := &Vertex{3, 4}

    fmt.Println("值类型变量调用值接收器方法:", vValue.AbsValue())     // 正常调用
    fmt.Println("指针类型变量调用指针接收器方法:", vPointer.AbsPointer()) // 正常调用

    // 尝试修改
    vValue.Scale(2) // 编译错误：vValue是值类型，不能调用指针接收器方法
    // 要么改成 (&vValue).Scale(2)
    // 要么 Scale 方法也使用值接收器，但那样就无法修改原始vValue了
}

// 原始定义
func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// 编译器隐式生成的等价方法 (概念上)
// func (v *Vertex) Abs() float64 {
//     return (*v).Abs() // 解引用后调用值接收器方法
// }

func main() {
    vPtr := &Vertex{3, 4}
    fmt.Println(vPtr.Abs()) // 编译器会自动调用上面隐式生成的 (*vPtr).Abs()
}

// 原始定义
func (v *Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    vVal := Vertex{3, 4}
    fmt.Println(vVal.Abs()) // 编译器会自动将其转换为 (&vVal).Abs()
}

package main

import (
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

// 情况A：指针接收器方法
func (v *Vertex) AbsA() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// 情况B：值接收器方法
func (v Vertex) AbsB() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    // 场景1: func (v *Vertex) AbsA() 和 v := &Vertex{3, 4}
    // 显式指针接收器，显式指针变量调用
    v1 := &Vertex{3, 4}
    fmt.Println("场景1 (指针接收器, 指针变量):", v1.AbsA()) // 结果: 5

    // 场景2: func (v Vertex) AbsB() 和 v := Vertex{3, 4}
    // 显式值接收器，显式值变量调用
    v2 := Vertex{3, 4}
    fmt.Println("场景2 (值接收器, 值变量):", v2.AbsB())   // 结果: 5

    // 场景3: func (v Vertex) AbsB() 和 v := &Vertex{3, 4}
    // 值接收器，但通过指针变量调用 -> 机制一 (指针调用值接收器)
    // 编译器转换为 (*v3).AbsB()
    v3 := &Vertex{3, 4}
    fmt.Println("场景3 (值接收器, 指针变量):", v3.AbsB())   // 结果: 5

    // 场景4: func (v *Vertex) AbsA() 和 v := Vertex{3, 4}
    // 指针接收器，但通过值变量调用 -> 机制二 (值调用指针接收器)
    // 编译器转换为 (&v4).AbsA()
    v4 := Vertex{3, 4}
    fmt.Println("场景4 (指针接收器, 值变量):", v4.AbsA())   // 结果: 5
}