Rust 中,在 struct 定义中使用范型的方法,是在 struct 名称后跟<范型标识符>,例如:

1
struct Int<T> 

而在 struct 的方法的定义中使用范型,则是形如:

1
impl<T> Int<T> 

注意这里有两个范型标识符<T>

impl 后面的<T>并不是可有可无的,如果其后有<T>,则后面 struct 名字后面的<T>才会被编译器认为是范型,否则编译器它是一个具体类型。

Rust 使用这种方式可以来实现对一个范型的不同具体类型定义不同的方法的功能。

如下面的代码所示,x 方法为所有 Int 实例所共有,但 x32 方法和 x64 方法则分别仅为具体类型为 i32 和 i64 的 Int 实例所有:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
struct Int<T> {
    x: T,
}
impl<T> Int<T> {
    fn x(&self) -> &T {
        &self.x
    }
}
impl Int<i32> {
    fn x32(&self) -> &i32 {
        &self.x
    }
}
impl Int<i64> {
    fn x64(&self) -> &i64 {
        &self.x
    }
}
fn main() {
    let p = Int { x: 5};
    println!("p.x = {}", p.x());
    println!("p.x32 = {}", p.x32());
    //下面的注释掉的是错误语句
    //println!("p.x64={}", p.x64());
    let p2 = Int {x: 5i64};
    println!("p2.x = {}", p2.x());
    //下面的注释掉的是错误语句
    //println!("p2.x32 = {}", p2.x32());
    println!("p2.x64 = {}", p2.x64());
}