重载与泛型函数

本章导读

给数字开平方和给复数开平方，该叫两个名字还是同一个名字？找两个 int 的最大值和找两个 string 的最大值，该写两份代码还是一份？前者是重载要回答的——同一个名字挂多个签名；后者是泛型要回答的——同一份逻辑抽象掉具体类型。本章把这两个机制连同它们的诊断信息一次讲透。

14.1 函数重载

同一个名字可以定义多个函数，只要签名不同（参数数量或参数类型不同）：

func show(int x)
    println("int: " + string(x))
end
func show(string s)
    println("string: " + s)
end
func show(int x, int y)
    println("pair: " + string(x) + "," + string(y))
end

show(42)       // int: 42
show("hi")     // string: hi
show(1, 2)      // pair: 1,2

重载是编译期的静态选择：编译器按实参的数量与类型挑选最匹配的签名，选完就是普通函数调用（第 11 章拾遗：静态分派）。返回类型不参与区分——只有参数列表构成重载身份（第 12 章拾遗 2：参数模式 byval/byref/out 也是签名的一部分）。

什么时候用重载？同一概念、多种输入形态：show 什么都可以、parse 从多种来源解析、构造函数接受不同初始化方式。如果两个函数做的事在概念上不同，还是给不同的名字——重载是"一词多义"，不该是"一词乱义"。

14.2 重载解析规则

多个候选签名时，编译器的选择逻辑实测如下：

func show(int x)
    println("int")
end
func show(float x)
    println("float")
end

show(1)            // int：整数字面量精确命中
show(1.5)          // float
int8 b = 3
show(b)            // int：int8 安全拓宽到 int（第 7 章）

规则提炼：先精确匹配，再按安全拓宽找最近的家。int8 没有专属签名时拓宽到 int（而不是 float）——拓宽方向遵守第 7 章的无损规则。完全对不上号时，报第 12 章坑 4 那条熟悉的 [sem] 没有匹配的函数重载。

把重载函数装进函数值时的歧义处理（回链第 13 章）：必须写出显式签名"点名"：

func twice(int x) as int
    return x * 2
end
func twice(string s) as string
    return s + s
end

func(int) as int p = twice        // 签名点名 int 版本
println(string(p(21)))            // 42
func(string) as string q = twice  // string 版本
println(q("ab"))                  // abab

直接 var v = twice 装重载函数会被拦下：[checked] bare overloaded function assigned to var requires an explicit func signature——歧义必须在赋值这一刻消掉，不留到运行期。

14.3 重载与默认参数/可变参

默认参数会让两个看似不同的签名在调用点"撞车"，xlang 在声明时就拦截：

f(1) 到底进哪个？语言不允许这个问题存在——带默认参数的签名与更短的签名冲突，声明即报错。设计重载家族时自查一遍：把每个签名"实际可接受的调用形态"列出来，有交集就是歧义。可变参 ... 同理，它能吞掉任意数量的实参，与固定参数重载组合时尤其要画清边界。

14.4 泛型函数与 turbofish

重载是"每个类型写一份"，泛型是"一份逻辑适配所有类型"。类型参数写在名字后面的尖括号里：

func max<T>(T a, T b) as T
    if a > b then
        return a
    end
    return b
end

int a = max::<int>(1, 2)
println(string(a))              // 2
string s = max::<string>("apple", "banana")
println(s)                        // banana：字符串按字典序比大小

调用点的 ::<int> 叫 turbofish（涡轮鱼，Rust 社区的昵称）——显式告诉编译器"T 这次是 int"。为什么要 ::？因为 max<int>(1, 2) 在表达式位置会被解析成"max 小于 int 再大于..."的比较链，:: 消掉这个歧义。

泛型函数的编译模型：每个具体实例化（int 版、string 版）都会独立做类型检查、独立生成代码——a > b 在 int 版是整数比较，在 string 版是字符串比较，各自静态安全。这和重载写两份的本质区别是：逻辑只维护一份，类型安全一份不少。

14.5 类型推导

turbofish 可以省略吗？实测结论：语句级调用可以推导，嵌套在别的调用里不行：

// ✅ 推导成功：实参给出 T = int
int m = max(3, 7)
println(string(m))

// ✅ auto 接收同样触发推导
auto m2 = max(3, 7)
println(type(m2))               // int

// ❌ 直接嵌进 string()：T 悬而未决
// println(string(max(3, 7)))

嵌套位置的报错提到 source T——类型参数还悬着没被实例化。推导规则"第一阶段"的边界就在这里：要么编译器能从当层语句推定 T，要么你写完整 turbofish。嵌套调用、长表达式链里，养成随手写 ::<T> 的习惯最稳妥（见坑 2）。

推导还可能撞上另一种失败——两个实参给 T 指了不同方向：

T 不可能既是 int 又是 string——报错把冲突双方直接点名。修法：统一实参类型，或显式实例化到公共类型。

14.6 能力约束

裸 <T> 意味着"任何类型都行"——但 max 里写了 a > b，并非任何类型都能比大小。约束把合法实例集合收紧到"有相应能力"的类型，语法是在类型参数后加 is：

func max<T is comparable>(T a, T b) as T
    if a > b then
        return a
    end
    return b
end

func save<T is comparable and json>(T obj)
    println("ok")
end
save::<int>(1)                 // ok：int 两个能力都有

内置能力约束就四个，背下来：

多约束用 and 连接，含义是"同时满足"。除四个能力名外，约束名还可以是已声明的 class 名——T is Entity 表示 T 必须是 Entity 或其子类（第 27 章）。写不存在的名字，编译期即拒：

约束在实例化时检查。类型不满足约束时的诊断：

报错指出了调用位置，但目前不点名具体缺哪个约束——多约束函数排查时，逐个对照约束清单即可。基础类型（int、string 等）对四个能力约束全部天然满足，上例 save::<int> 顺利通过就是证明。

14.7 泛型与重载的组合

泛型签名与具体签名可以共存于同一个名字下，各管一段：

func max<T>(T a, T b) as T
    if a > b then
        return a
    end
    return b
end
func max(int a, int b, int c) as int
    return max::<int>(max::<int>(a, b), c)
end

println(string(max(1, 5, 3)))      // 5：三参数具体版
println(string(max::<int>(2, 4))) // 4：两参数泛型版

注意具体版内部复用了泛型版——具体重载做特化，泛型做兜底，特化内部回调泛型，这是标准库式的分层手法。调用解析时 turbofish 也起到"指路"作用：写了 ::<int> 就直奔泛型签名，普通调用按 14.2 节规则匹配。

深入细节

⚠️ 常见错误

以下报错全部来自真实编译器输出（文件路径已缩短）。

本章小结

复习题

编程练习