企业官网建设流程全解析

• 教程
• 文档

导读

在 Rust 中，多个 trait 可以定义同名方法，同一个类型也可以同时实现这些 trait，甚至还可以在类型上直接定义同名方法。当调用这些重名方法时，Rust 编译器需要知道你到底想调用哪一个。本文以本书 redirects/ufcs.md 记录的经典案例为主线，系统讲解同名方法（以及同名关联函数）的冲突场景与三种调用写法——直接调用、Trait::method限定调用、<Type as Trait>::method完全限定语法（即历史上被称为 UFCS，Universal Function Call Syntax）——并对照 源码章节 与可运行示例 listings/ch20-advanced-features/listing-20-17/src/main.rs 展开深挖。读完本文，你将能够准确判断何时需要消歧、何时可以省略，并写出可编译、可预期的 Rust 方法调用代码。

问题的根源：trait 之间允许同名方法

Rust 并不禁止两个 trait 定义同名方法，也不禁止你在一个类型上同时实现它们，甚至允许你在类型上直接实现与 trait 方法同名的固有方法（inherent method）。这样的自由度带来一个问题：调用重名方法时，Rust 无法凭空猜测你的意图，你必须显式告诉它用哪一个实现。

在 The Rust Programming Language 的当前版本中，这一主题被系统收录于 高级 trait 章节 的 "Disambiguating Between Identically Named Methods" 小节，并在旧版链接 redirects/ufcs.md 中保留了经典的Pilot/Wizard/Human示例作为导引。下面是两个 trait 与一个固有方法同时存在fly的完整代码（对应可运行示例 listing-20-17/src/main.rs）：

trait Pilot { fn fly(&self); } trait Wizard { fn fly(&self); } struct Human; impl Pilot for Human { fn fly(&self) { println!("This is your captain speaking."); } } impl Wizard for Human { fn fly(&self) { println!("Up!"); } } impl Human { fn fly(&self) { println!("*waving arms furiously*"); } } fn main() { let person = Human; Pilot::fly(&person); Wizard::fly(&person); person.fly(); }

这里存在三个名为fly的实现：Pilot::fly、Wizard::fly以及直接定义在Human上的固有方法。接下来逐一说明如何区分它们。

方法调用（带 self 参数）的三种写法

写法一：person.fly()——默认调用固有方法

当使用接收者语法调用方法时，编译器优先选择直接定义在类型上的固有方法，而不是 trait 方法。示例 listing-20-18/src/main.rs 展示了这一点：

fn main() { let person = Human; person.fly(); }

运行输出为：

*waving arms furiously*

说明person.fly()命中impl Human中的固有方法，而不是Pilot或Wizard的实现。这是 Rust 在存在多个同名方法时的默认消歧规则：类型上的固有方法优先于 trait 方法。

写法二：Pilot::fly(&person)——用 trait 名限定

要调用 trait 中的方法，可以在方法名前加上 trait 名进行限定，并显式传入接收者。示例 listing-20-19/src/main.rs 的main中同时使用了三种写法：

fn main() { let person = Human; Pilot::fly(&person); Wizard::fly(&person); person.fly(); }

运行结果（见 listing-20-19/output.txt）：

$ cargo run Compiling traits-example v0.1.0 (file:///projects/traits-example) Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.46s Running `target/debug/traits-example` This is your captain speaking. Up! *waving arms furiously*

三条输出依次对应Pilot::fly、Wizard::fly、person.fly()。注意，Human::fly(&person)与person.fly()等价，但只有在需要消歧时才值得写得更冗长；否则直接使用接收者语法即可。这里的关键点是：fly方法带有self参数，编译器可以依据self的类型推断出该 trait 的具体实现类型，因此Trait::method这种写法已经足够明确。

关联函数（无 self 参数）：Trait::name不再够用

方法通过self参数携带了"接收者类型"信息，而没有self参数的关联函数（associated function）则不具备这一信息。当多个类型或多个 trait 定义了同名关联函数时，Trait::name这种写法会让编译器无法确定你想调用哪个具体实现。

书中的经典例子是动物收容所场景：希望把所有小狗命名为 Spot。定义Animaltrait 的关联函数baby_name，同时直接在Dog上定义同名关联函数，并让Dog实现Animal（完整代码见 listing-20-20/src/main.rs）：

trait Animal { fn baby_name() -> String; } struct Dog; impl Dog { fn baby_name() -> String { String::from("Spot") } } impl Animal for Dog { fn baby_name() -> String { String::from("puppy") } } fn main() { println!("A baby dog is called a {}", Dog::baby_name()); }

此时Dog::baby_name()调用的是定义在Dog上的固有关联函数，输出为A baby dog is called a Spot，而Animaltrait 的实现（返回"puppy"）并没有被调用。

报错：cannot call associated function on trait

如果直接把main改成Animal::baby_name()（见 listing-20-21/src/main.rs），编译器会报出错误 E0790（完整输出见 listing-20-21/output.txt）：

$ cargo run Compiling traits-example v0.1.0 (file:///projects/traits-example) error[E0790]: cannot call associated function on trait without specifying the corresponding `impl` type --> src/main.rs:20:43 | 2 | fn baby_name() -> String; | ------------------------- `Animal::baby_name` defined here ... 20 | println!("A baby dog is called a {}", Animal::baby_name()); | ^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait | help: use the fully-qualified path to the only available implementation | 20 | println!("A baby dog is called a {}", <Dog as Animal>::baby_name()); | +++++++ +

错误信息本身也给出了修复建议：因为Animal::baby_name没有self参数，且可能存在其他实现了Animal的类型，Rust 无法确定你要调用哪个实现，必须使用完全限定语法。

完全限定语法（Fully Qualified Syntax）的完整形式

将main改为如下写法即可解决问题（完整代码见 listing-20-22/src/main.rs）：

fn main() { println!("A baby dog is called a {}", <Dog as Animal>::baby_name()); }

运行结果（见 listing-20-22/output.txt）：

$ cargo run Compiling traits-example v0.1.0 (file:///projects/traits-example) Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s Running `target/debug/traits-example` A baby dog is called a puppy

<Dog as Animal>::baby_name()的语义是：把Dog类型当作Animal来调用其baby_name。尖括号中的类型注解同时指定了"哪个 trait"和"哪个实现类型"，因此编译器不再有歧义。

通用形式

在 ch20-02-advanced-traits.md 中，完全限定语法的通用形式被定义为：

<Type as Trait>::function(receiver_if_method, next_arg, ...);

• 对于方法（带self/&self等接收者），第一个参数是接收者；
• 对于关联函数（无接收者），直接从普通参数列表开始，如<Dog as Animal>::baby_name()。

何时可以省略

完全限定语法在任何函数或方法调用处都是合法的，但你通常不需要写它。编译器能根据程序中其他信息推断出来的部分都可以省略，因此：

• 有self参数的 trait 方法，用Trait::method(&self_value)就够了，因为self的类型揭示了实现类型；
• 类型自身的固有方法，直接person.fly()或Type::method()即可；
• 只有当存在多个同名实现且 Rust 需要额外信息来确定目标时，才必须使用<Type as Trait>::method这种更冗长的形式。

从 UFCS 到完全限定语法的演进

"Universal Function Call Syntax（UFCS）"这个名称来自 Rust 早期设计讨论，指代"任何函数都能以统一语法调用"的设想。第一版《The Rust Programming Language》曾专门以 first-edition/src/ufcs.md 讲解这一概念，而第一版书籍目前已不再随 Rust 文档分发。在当前版本中，这一机制被重新命名为fully qualified syntax（完全限定语法），并在 ch20-02-advanced-traits.md 中完整展开。旧链接 redirects/ufcs.md 专门用于把读者引导到上述新版章节。

在 Rust 2018 版次中也有对应的组织方式：早期章节结构下该内容位于 2018-edition/src/ch20-02-advanced-traits.md，指向的是同一套高级 trait 内容。读者可以根据自己使用的版次选择对应章节，但语法本身在所有现代 Rust 版本中保持一致。

实战要点速查

可复现实验路径

本文所有代码均为仓库内真实可运行的示例，可直接对照：

• 同名 trait 方法定义与三种调用写法：listing-20-17/src/main.rs（默认行为见 listing-20-18/src/main.rs）；
• trait 限定调用与运行输出：listing-20-19/src/main.rs 与 listing-20-19/output.txt；
• 同名关联函数冲突：listing-20-20/src/main.rs；
• 错误 E0790 复现与编译器建议：listing-20-21/src/main.rs 与 listing-20-21/output.txt；
• 完全限定语法修复：listing-20-22/src/main.rs 与 listing-20-22/output.txt。

如果希望深入了解 trait 的其余高级能力（关联类型、默认泛型参数、运算符重载、supertrait、newtype 模式实现外部 trait 等），可以继续阅读 高级 trait 完整章节；若你关注的是旧版目录结构，也可以参考 second-edition 的同名章节 与 redirects/README.md 了解版本导航关系。

• 教程
• 文档