【Rust练习】17.泛型

练习题来自：https://practice-zh.course.rs/generics-traits/generics.html

函数

1

// 填空
struct A;          // 具体的类型 `A`.
struct S(A);       // 具体的类型 `S`.
struct SGen<T>(T); // 泛型 `SGen`.

fn reg_fn(_s: S) {}

fn gen_spec_t(_s: SGen<A>) {}

fn gen_spec_i32(_s: SGen<i32>) {}

fn generic<T>(_s: SGen<T>) {}

fn main() {
    // 使用非泛型函数
    reg_fn(__);          // 具体的类型
    gen_spec_t(__);   // 隐式地指定类型参数  `A`.
    gen_spec_i32(__); // 隐式地指定类型参数`i32`.

    // 显式地指定类型参数 `char`
    generic::<char>(__);

    // 隐式地指定类型参数 `char`.
    generic(__);
}

将泛型的各种用法复习了一遍：

1. Rust声明一个泛型函数也使用尖括号，但是是直接写在函数名字后面的；C++则是使用template关键字写在函数返回值的前面（一般习惯换行，但本质就是最前面）
2. Rust显式指定类型参数使用双分号::，而C++显式的语法类似Rust的声明，写在函数名字后面。

fn main() {
    // 使用非泛型函数
    let a = A;
    let s = S(a);
    let b = A;
    let sgen_a = SGen(b);
    let num = 32;
    let sgen_i32 = SGen(num);
    reg_fn(s);          // 具体的类型
    gen_spec_t(sgen_a);   // 隐式地指定类型参数  `A`.
    gen_spec_i32(sgen_i32); // 隐式地指定类型参数`i32`.

    // 显式地指定类型参数 `char`
    let sgen_char = SGen('a');
    generic::<char>(sgen_char);

    // 隐式地指定类型参数 `char`.
    let sgen_char = SGen('a');
    generic(sgen_char);
}

题外话，我真的不适应结构体后面跟着括号居然是元组结构体而不是结构体的构造函数调用，可能我需要多写点Rust代码。。。

2

// 实现下面的泛型函数 sum
fn sum

fn main() {
    assert_eq!(5, sum(2i8, 3i8));
    assert_eq!(50, sum(20, 30));
    assert_eq!(2.46, sum(1.23, 1.23));
}

作为替代面向对象中接口的设计，我得说Rust的这个特征设计得不是很好，至少语法很难看。我也不是很理解加法也要搞一个特征。你大可以让无法相加的泛型实现编译失败，反正Rust这里也需要做编译期检查。

fn sum<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

3

// 实现一个结构体 Point 让代码工作


fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

这里给出一种

struct Point<T>{
    x: T,
    y: T,
}

4

// 修改以下结构体让代码工作
struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    // 不要修改这行代码！
    let p = Point{x: 5, y : "hello".to_string()};
}

y的类型错了

struct Point<T> {
    x: T,
    y: String,
}

5

// 为 Val 增加泛型参数，不要修改 `main` 中的代码
struct Val {
    val: f64,
}

impl Val {
    fn value(&self) -> &f64 {
        &self.val
    }
}


fn main() {
    let x = Val{ val: 3.0 };
    let y = Val{ val: "hello".to_string()};
    println!("{}, {}", x.value(), y.value());
}

这里给出一种

struct Val<T> {
    val: T,
}

impl<T> Val<T> {
    fn value(&self) -> &T {
        &self.val
    }
}

我倒是不经常在C++里使用模板类。。。

6

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    // 实现 mixup，不要修改其它代码！
    fn mixup
}

fn main() {
    let p1 = Point { x: 5, y: 10 };
    let p2 = Point { x: "Hello", y: '中'};

    let p3 = p1.mixup(p2);

    assert_eq!(p3.x, 5);
    assert_eq!(p3.y, '中');
}

分清楚结构体泛型和函数泛型即可

impl<T, U> Point<T, U> {
    // 实现 mixup，不要修改其它代码！
    fn mixup<X,Y>(self, p2: Point<X, Y>) -> Point<T, Y>{
        Point{
            x: self.x,
            y: p2.y,
        }
    }
}

7

// 修复错误，让代码工作
struct Point<T> {
    x: T,
    y: T,
}

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point{x: 5, y: 10};
    println!("{}",p.distance_from_origin())
}

我感觉这是最简单的改法，虽然作者本意可能不是这个：

fn main() {
    let p = Point{x: 5.0, y: 10.0};
    println!("{}",p.distance_from_origin())
}