Go语言中自定义类型作为Map键的陷阱与解决方案：深入理解指针与值类型

package main

import "fmt"

type Point struct {
    row int
    col int
}

// NewPoint 返回一个指向新Point实例的指针
func NewPoint(r, c int) *Point {
    return &Point{r, c}
}

// String 方法用于方便打印Point指针
func (p *Point) String() string {
    if p == nil {
        return "<nil>"
    }
    return fmt.Sprintf("{%d, %d}", p.row, p.col)
}

func main() {
    fmt.Println("--- 场景一：使用 *Point 作为键 (指针相等性) ---")
    set := make(map[*Point]bool)

    p1 := NewPoint(0, 0)
    p2 := NewPoint(0, 2)
    p3 := NewPoint(0, 2) // p3 的内容与 p2 相同，但地址不同

    fmt.Printf("p1 地址: %p, 值: %v\n", p1, p1)
    fmt.Printf("p2 地址: %p, 值: %v\n", p2, p2)
    fmt.Printf("p3 地址: %p, 值: %v\n", p3, p3) // 注意 p2 和 p3 的地址不同

    // 将 p1 和 p2 添加到 map
    set[p1] = true
    set[p2] = true
    fmt.Printf("添加 p1, p2 后，set 长度: %d, 内容: %v\n", len(set), set) // 长度为 2

    // 尝试查找 p3。尽管其内容与 p2 相同，但由于地址不同，map 认为它不存在
    _, ok := set[p3]
    if !ok {
        fmt.Println("查找 p3: 不存在 (正确，因为指针地址不同)") // 预期输出
    } else {
        fmt.Println("查找 p3: 存在 (错误)")
    }

    // 查找 p2 自身，它存在于 map 中
    _, ok = set[p2]
    if ok {
        fmt.Println("查找 p2: 存在 (正确)") // 预期输出
    } else {
        fmt.Println("查找 p2: 不存在 (错误)")
    }

    fmt.Println("Set 内容:")
    for k, v := range set {
        fmt.Printf("  键地址: %p, 键值: %v -> %t\n", k, k, v)
    }
}

package main

import "fmt"

type Point struct {
    row int
    col int
}

// String 方法用于方便打印Point值
func (p Point) String() string { // 注意这里是值接收者
    return fmt.Sprintf("{%d, %d}", p.row, p.col)
}

func main() {
    fmt.Println("\n--- 场景二：使用 Point 作为键 (值相等性) ---")
    // Map 的键是 Point (值类型)
    set := make(map[Point]bool)

    p1 := Point{0, 0}
    p2 := Point{0, 2}
    p3 := Point{0, 2} // p3 的内容与 p2 相同

    fmt.Printf("p1 值: %v\n", p1)
    fmt.Printf("p2 值: %v\n", p2)
    fmt.Printf("p3 值: %v\n", p3)

    // 将 p1 和 p2 添加到 map
    set[p1] = true
    set[p2] = true
    fmt.Printf("添加 p1, p2 后，set 长度: %d, 内容: %v\n", len(set), set) // 长度为 2

    // 尝试查找 p3。由于其内容与 p2 相同，map 认为它存在
    _, ok := set[p3]
    if ok {
        fmt.Println("查找 p3: 存在 (正确，因为值相等)") // 预期输出
    } else {
        fmt.Println("查找 p3: 不存在 (错误)")
    }

    fmt.Println("Set 内容:")
    for k, v := range set {
        fmt.Printf("  键值: %v -> %t\n", k, v)
    }
}

package main

import "fmt"

type Point struct {
    row int
    col int
}

func NewPoint(r, c int) *Point {
    return &Point{r, c}
}

func (p *Point) String() string {
    if p == nil {
        return "<nil>"
    }
    return fmt.Sprintf("{%d, %d}", p.row, p.col)
}

// pointToKey 将 Point 的坐标转换为一个唯一的 int64 键
func pointToKey(p *Point) int64 {
    // 假设 row 和 col 的值在 int32 范围内，这样可以安全地组合成 int64
    // 更复杂的结构体可能需要更复杂的哈希或字符串转换
    return int64(p.row)<<32 + int64(p.col)
}

func main() {
    fmt.Println("\n--- 场景三：使用复合键 (int64) 存储 *Point ---")
    // Map 的键是 int64，值是 *Point
    set := make(map[int64]*Point)

    p1 := NewPoint(0, 0)
    p2 := NewPoint(0, 2)
    p3 := NewPoint(0, 2) // p3 的内容与 p2 相同，但地址不同

    fmt.Printf("p1 地址: %p, 值: %v\n", p1, p1)
    fmt.Printf("p2 地址: %p, 值: %v\n", p2, p2)
    fmt.Printf("p3 地址: %p, 值: %v\n", p3, p3)

    // 使用 pointToKey 生成键并添加元素
    set[pointToKey(p1)] = p1
    set[pointToKey(p2)] = p2 // pointToKey(p2) 和 pointToKey(p3) 会生成相同的键
    fmt.Printf("添加 p1, p2 后，set 长度: %d, 内容: %v\n", len(set), set) // 长度为 2

    // 尝试查找 p3，使用其生成的复合键
    // 因为 pointToKey(p3) 与 pointToKey(p2) 相同，所以会找到 p2 对应的条目
    foundPoint, ok := set[pointToKey(p3)]
    if ok {
        fmt.Printf("查找 p3: 存在 (正确，因为复合键相等)，找到的 Point: %v (地址: %p)\n", foundPoint, foundPoint) // 预期输出
    } else {
        fmt.Println("查找 p3: 不存在 (错误)")
    }

    fmt.Println("Set 内容:")
    for k, v := range set {
        fmt.Printf("  键: %d, 值: %v (地址: %p) -> true\n", k, v, v)
    }
}