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 {
    return fmt.Sprintf("{%d, %d}", p.row, p.col)
}

func main() {
    fmt.Println("--- 场景一：使用指针作为Map键 ---")
    // 声明一个键为 *Point 类型，值为 bool 类型的 map
    set := make(map[*Point]bool)

    p1 := NewPoint(0, 0) // 创建第一个 Point 指针
    p2 := NewPoint(0, 0) // 创建第二个 Point 指针，其值与 p1 相同，但内存地址不同

    // 将 p1 和 p2 添加到 map 中
    set[p1] = true
    set[p2] = true // 即使值相同，p2 也会作为新键被添加，因为它是一个不同的指针

    fmt.Printf("p1 地址: %p, p2 地址: %p\n", p1, p2)
    fmt.Println("Map 内容:")
    for k := range set {
        fmt.Printf("  Key: %s (地址: %p)\n", k, k)
    }
    fmt.Printf("Map 大小: %d\n", len(set)) // 预期输出 2，因为 p1 和 p2 是不同的指针

    // 尝试查找一个逻辑上相等但新创建的 Point
    _, ok := set[NewPoint(0, 0)]
    fmt.Printf("查找 NewPoint(0,0) 是否存在: %t (预期为 false，因为其地址与 map 中已有的键不同)\n", ok)
}

package main

import "fmt"

// Point 定义为结构体，直接用作map键
type Point struct {
    row int
    col int
}

func main() {
    fmt.Println("\n--- 场景二：直接使用结构体作为Map键 ---")
    // 声明一个键为 Point 类型，值为 bool 类型的 map
    set := make(map[Point]bool)

    p1 := Point{0, 0} // 创建第一个 Point 结构体值
    p2 := Point{0, 0} // 创建第二个 Point 结构体值，其值与 p1 相同

    // 将 p1 和 p2 添加到 map 中
    set[p1] = true
    set[p2] = true // 不会添加新的条目，因为 p2 与 p1 在值上被视为相同的键

    fmt.Printf("p1: %v, p2: %v\n", p1, p2)
    fmt.Println("Map 内容:")
    for k := range set {
        fmt.Printf("  Key: %v\n", k)
    }
    fmt.Printf("Map 大小: %d\n", len(set)) // 预期输出 1

    // 尝试查找一个逻辑上相等的 Point
    _, ok := set[Point{0, 0}]
    fmt.Printf("查找 Point{0,0} 是否存在: %t (预期为 true)\n", ok)
}

package main

import "fmt"

type Point struct {
    row int
    col int
}

// GetCompositeKey 为 Point 生成一个 int64 类型的复合键
// 这里将 row 和 col 组合，确保组合方式的唯一性。
// 对于 int32 范围内的坐标，可以通过位移操作高效组合。
func (p Point) GetCompositeKey() int64 {
    // 将 row 左移 32 位，然后与 col 进行位或操作，
    // 确保 row 和 col 在 int32 范围内不会冲突。
    return int64(p.row)<<32 | int64(p.col)
}

func main() {
    fmt.Println("\n--- 场景三：使用复合键作为Map键 ---")
    // 声明一个键为 int64 类型，值为 bool 类型的 map
    set := make(map[int64]bool)

    p1 := Point{0, 0}
    p2 := Point{0, 0}

    // 将 Point 的复合键添加到 map 中
    set[p1.GetCompositeKey()] = true
    set[p2.GetCompositeKey()] = true // 不会添加新的条目，因为它们的复合键相同

    fmt.Printf("p1: %v (复合键: %d), p2: %v (复合键: %d)\n", p1, p1.GetCompositeKey(), p2, p2.GetCompositeKey())
    fmt.Println("Map 内容:")
    for k := range set {
        fmt.Printf("  Key: %d\n", k)
    }
    fmt.Printf("Map 大小: %d\n", len(set)) // 预期输出 1

    // 尝试查找一个逻辑上相等的 Point
    _, ok := set[Point{0, 0}.GetCompositeKey()]
    fmt.Printf("查找 Point{0,0} 是否存在: %t (预期为 true)\n", ok)
}