泛型：类型参数、约束与泛型实践

一、学习目标

二、知识讲解

2.1 类型参数与类型推导

Go 1.18 引入了泛型，允许我们在编写函数或类型时，将具体的类型抽象为“类型参数”。

是什么： 泛型函数在签名中通过方括号 [] 声明类型参数。调用时，编译器会根据传入的实参自动推导类型参数，这一过程称为类型推导。

为什么这样设计： 在没有泛型之前，若要对不同类型执行相同逻辑（如求和），只能为每种类型编写单独的函数（如 SumInt、SumFloat64），或使用 interface{} 配合类型断言，代码冗余且缺乏类型安全。泛型在编译期生成特定类型的代码，既保证了类型安全，又避免了运行时的类型断言开销。

怎么用：

func Sum[T int | float64](a, b T) T {
    return a + b
}

调用 Sum(1, 2) 时，编译器推导 T 为 int；调用 Sum(1.0, 2.0) 时，推导 T 为 float64。

2.2 约束定义与 comparable

约束（Constraint） 是类型参数必须满足的条件。约束通常是一个接口类型。

~T 与联合类型： - ~int 表示底层类型为 int 的所有类型（包括 int 本身及其别名）。 - int | float64 表示类型必须是 int 或 float64。

comparable： comparable 是 Go 内置的一个约束，表示该类型支持 == 和 != 操作。 - 版本提示：Go 1.18/1.19 中 comparable 只接受严格可比较类型；Go 1.20 起放宽为也接受可比较的接口类型（如 any）。在 go.mod 声明 go 1.20 以下时，若使用 any 满足 comparable 会编译报错。 - 注意：comparable 只保证 == 可用于该类型；T=any 时若运行时动态类型不可比较（slice/map/func 等），a == b 会在运行期 panic，泛型代码里要留意。

接口约束同样是结构化的：类型只要拥有约束要求的方法或底层类型就满足约束，无需显式声明；~T 与联合类型让约束能按底层类型匹配，这是泛型比普通接口多出来的一层表达力。

2.3 泛型数据结构

泛型不仅用于函数，也用于结构体。泛型结构体在实例化时，其字段类型也随之确定。

2.4 泛型与接口的选择

• 何时用泛型：当操作依赖于具体类型的底层行为（如数值运算、comparable 比较）且需要高性能时。
• 何时用接口：当行为是多态的（不同类型实现相同方法），且不关心底层类型时。接口更灵活，泛型更精确。

三、示例代码

示例 1：泛型函数与约束

演示如何使用联合类型约束和 comparable 约束编写通用的最大值函数。

package main

import (
    "fmt"
)

// Number 约束：底层类型为 int 或 float64 的类型
type Number interface {
    ~int | ~float64
}

// Max 返回两个相同类型 Number 中的较大值
func Max[T Number](a, b T) T {
    if a > b {
        return a
    }
    return b
}

func main() {
    // 类型推导：T 推导为 int
    maxInt := Max(3, 5)
    fmt.Printf("Max(3, 5) = %d\n", maxInt)

    // 类型推导：T 推导为 float64
    maxFloat := Max(3.14, 2.71)
    fmt.Printf("Max(3.14, 2.71) = %.2f\n", maxFloat)

    // Go 1.21 起内置了 min/max，对有序类型可直接使用（max(3, 4)）；
    // 本示例的 Max[T Number] 主要用于演示约束定义。
    // 注意内置函数是小写 max，与这里的大写 Max 不冲突。
}

运行结果（预期输出）：

Max(3, 5) = 5
Max(3.14, 2.71) = 3.14

示例 2：泛型 Map 与 comparable

演示如何使用 comparable 约束实现一个泛型计数器，并处理内存保留问题。

package main

import (
    "fmt"
)

// CountMap 统计元素出现次数的泛型结构
type CountMap[T comparable] struct {
    counts map[T]int
}

// NewCountMap 创建一个新的 CountMap
func NewCountMap[T comparable]() *CountMap[T] {
    return &CountMap[T]{
        counts: make(map[T]int),
    }
}

// Increment 增加元素计数
func (cm *CountMap[T]) Increment(key T) {
    cm.counts[key]++
}

// GetCount 获取元素计数
func (cm *CountMap[T]) GetCount(key T) int {
    return cm.counts[key]
}

func main() {
    cm := NewCountMap[string]()
    cm.Increment("apple")
    cm.Increment("banana")
    cm.Increment("apple")

    fmt.Printf("apple: %d\n", cm.GetCount("apple"))
    fmt.Printf("banana: %d\n", cm.GetCount("banana"))
}

运行结果（预期输出）：

apple: 2
banana: 1

四、常见错误与避坑指南

五、最佳实践

六、练习题

1. 概念题：解释 ~int 和 int 在约束中的区别，并说明 comparable 约束的作用。
2. 编码题：编写一个泛型函数 Reverse[T any](s []T) []T，用于反转切片，并编写 main 函数测试 int 和 string 切片。
3. 进阶/调试题：下面的泛型队列可以编译运行。请分析 Dequeue 中 q.items = q.items[1:] 在元素为指针/大对象时的内存保留（retention）问题，并给出改进写法。 ```go package main

type Queue[T any] struct { items []T }

func (q *Queue[T]) Enqueue(item T) { q.items = append(q.items, item) }

func (q *Queue[T]) Dequeue() (T, bool) { if len(q.items) == 0 { var zero T return zero, false } item := q.items[0] // 问题代码：直接截断 q.items = q.items[1:] return item, true } ```

七、练习参考答案

package main

import "fmt"

func Reverse[T any](s []T) []T {
    reversed := make([]T, len(s))
    for i, v := range s {
        reversed[len(s)-1-i] = v
    }
    return reversed
}

func main() {
    ints := []int{1, 2, 3}
    fmt.Println(Reverse(ints)) // [3 2 1]

    strs := []string{"a", "b", "c"}
    fmt.Println(Reverse(strs)) // [c b a]
}

package main

import "fmt"

type Queue[T any] struct {
    items []T
}

func (q *Queue[T]) Enqueue(item T) {
    q.items = append(q.items, item)
}

func (q *Queue[T]) Dequeue() (T, bool) {
    if len(q.items) == 0 {
        var zero T
        return zero, false
    }
    item := q.items[0]
    // 修复：将已移除位置的元素置零，释放底层数组引用
    var zero T
    q.items[0] = zero
    // 截断切片
    q.items = q.items[1:]
    return item, true
}

func main() {
    q := &Queue[string]{}
    q.Enqueue("hello")
    q.Enqueue("world")

    item, _ := q.Dequeue()
    fmt.Println(item) // hello
}

八、本课小结