泛型

函数

1. 🌟🌟🌟

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

7. fn reg_fn(_s: S) {}

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

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

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

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

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

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

1. 🌟🌟

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

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

结构体和 impl

1. 🌟

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

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

1. 🌟🌟

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

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

1. 🌟🌟

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

7. impl Val {
8. fn value(&self) -> &f64 {
9. &self.val
10. }
11. }

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

方法

1. 🌟🌟🌟

1. struct Point<T, U> {
2. x: T,
3. y: U,
4. }

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

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

15. let p3 = p1.mixup(p2);

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

1. 🌟🌟

2. // 修复错误，让代码工作
3. struct Point<T> {
4. x: T,
5. y: T,
6. }

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

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

你可以在这里找到答案(在 solutions 路径下)