rust-course/basic/trait/generic

[giscus[bot]]

basic/trait/generic

https://course.rs/basic/trait/generic.html

[giveahug]

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

impl<T, U> Point<T, U> {
fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
Point {
x: self.x,
y: other.y,
}
}
}

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

let p3 = p1.mixup(p2);

println!("p3.x = {}, p3.y = {}", p3.x, p3.y);

}
//--------------------------------------------
p1.mixup(p2);
为啥mixup只传了一个参数

[sunface]

这是一个方法

[linbird]

p1.mixup(p2)可以理解为mixup(p1, p2)，这也是实际的调用方式，只不过后者的调用形式是编译器作用后的结果，即我们以 p1.mixup(p2)的形式通过编译器完成了函数调用mixup(p1, p2)，这和C++中是一样的

[edcijn]

self是由编译器传入的，和其它OOP里的self或this类似，区别只是显式或隐式传入。

[bluecode2017]

fn mixup<V, W>(self, other: Point<V, W>)

定义里就是一个参数 other

[codecow-s]

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

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

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, '中');

}

为什么self改为&self不可以

[BiteFoo]

刚好我看到这里的时候也在想这个问题，现在明白了一些

[potatoshred]

1. 编译器先检查类型 T 是否实现 Copy trait​，​​若 T 实现了 Copy​​执行 ​​按位复制，
2. 若未实现则执行 ​​Move 语义​​，转移所有权，
3. 但&self是不可变借用，所以编译失败

[Resorie]

&self 创建一个不可变引用为什么要实现 Copy trait 啊，晕:(

[kingqiuol]

应该为了安全吧，Rust里面每一个值都拥有唯一变量，出现赋值或所有权转移时，又由于&self不可变，不能通过赋值或所有权转移来进行赋值的操作，所以会报错；如果实现copy那么可以不改变原来的struct进行拷贝赋值操作或者通过clone()形式进行赋值；但是泛型T的类型不知道，可能是非基本类型，所以传递self这两种情况都可以进行赋值；

[Creat55]

楼上回复都不太对，其实是可以的，但因为把self改为引用&self了，所以返回值也得是&T。(Copy trait也是一种办法，但应该不合题主的原意)。所以方法应该改为impl<T, U> Point<T, U> {
// 实现 mixup，不要修改其它代码！
fn mixup<V,W>(&self,other:Point<V,W>)->Point<&T,W>{
Point{x:&self.x,y:other.y}
}
} 另外在使用时， assert_eq!(p3.x, 5); 这里x不会自动解引用，所以加解。

[wfk007]

我为啥觉得为了实现泛型 add 添加的 std::ops::Add<Output = T> 语法有点丑陋...

[Jly13]

泛型约束还有后置型的，形式更清晰一些，使用关键字where。

fn f1<T>(v:T) -> i32
  where T:Add { // 左边就是泛型约束了
  // ...
}

[bluecode2017]

可以写一行 表示T必须能做Add操作
fn f1(v:T) -> i32 where T:Add {
// ...
}

[ghost]

<Output=T> 是干什么的啊，这种语法以前没见过啊 /(ㄒoㄒ)/~~

[iostiny]

看到这里，我去搜了一下Where后置限制是谁先创造出来（Haskell）的。

目前我看到的语言有Swift/Rust，两种语言的使用方式类似，都是用于泛型类型遵从特定的协议/特性。

[352079]

<Output=T> 是干什么的啊，这种语法以前没见过啊 /(ㄒoㄒ)/~~
Output是关联类型实现trait的时候要通过type Output = 类型 ; 来指定Output的类型
因为是泛型函数所以需要为Add trait 通过 <Output = T>来指定Output的类型

[90designer]

Assert<{ core::mem::size_of::() < 768 }>: IsTrue,

这个 const泛型表达式，好丑，好难理解

[i-CNNN]

// 这一行，你拆开来看就觉得容易理解了：
Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue

// 1. core::mem::size_of::<T>() 这里返回一个类型占用内存的大小值
// 2. { core::mem::size_of::() < 768 } 这里是一个表达式，表达式返回一个bool值
// 类似于：
let x = {2 < 3};
// 3. <{ core::mem::size_of::<T>() < 768 }>: IsTrue 这句就是约束，这个内存大小一定要小于768（返回True）

[qianhaiyang]

great！！！

[sinopec]

c++泛型比这还丑，奇技淫巧太多了。。。。 这个至少第一次看都还能看的明白

[BiteFoo]

C++的看了一部分就开始脑瓜子疼了，可能是写这类范型代码不多导致的

[caoxiemeihao]

可与 TypeScript 的泛型一战否 🐶

[jinliming2]

any 警告
unknown 警告
as unknown as xxx 警告

[suica]

rust有常量表达式的约束，比ts的原生的泛型约束表达能力更加丰富一点

[endlesstravel]

看到这里给我整笑了
我也来一个 (xx as any) 警告
很多时候，我恨不得把 ts 函数输入的每个参数都校验一遍 😭

[endlesstravel]

看到这里给我整笑了 我也来一个 (xx as any) 警告 很多时候，我恨不得把 ts 函数输入的每个参数都校验一遍 😭

不过 ts 里边的泛型能整出一堆奇怪的玩意，配合代码校验提示，我有时还是挺佩服ts语言开发组的

[ztsweet]

• rustc : 1.61

fn main() {
    // println!("Hello, world!");
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}
fn add<T: std::ops::Add<Output = T>>(a:T, b:T) -> T {
    a + b
}
fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

---

error[E0508]: cannot move out of type `[T]`, a non-copy slice
  --> main.rs:26:23
   |
26 |     let mut largest = list[0];
   |                       ^^^^^^^
   |                       |
   |                       cannot move out of here
   |                       move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait
   |                       help: consider borrowing here: `&list[0]`

error[E0507]: cannot move out of a shared reference
  --> main.rs:28:18
   |
28 |     for &item in list.iter() {
   |         -----    ^^^^^^^^^^^
   |         ||
   |         |data moved here
   |         |move occurs because `item` has type `T`, which does not implement the `Copy` trait
   |         help: consider removing the `&`: `item`

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0507, E0508.
For more information about an error, try `rustc --explain E0507`.

[i-CNNN]

只需要给T加上Copy的Trait就可以了.

largest<T: PartialOrd + Copy>

[yuhao00]

默认为move语义，不能通过引用把所有权拿走，除非你Copy一份，原来那一份你还是不能动。

[Pursue-LLL]

首先引用不允许转移所有权

list是切片引用类型 &[T]（引用的是数组某些元素的切片），但是list里的元素是T类型，而不是&T

对于 Copy 类型（如 i32、u32 等），索引操作会直接将值复制到新的变量中，因此不会引起所有权转移。
对于非 Copy 类型（如 String、Vec 等），如果你尝试通过索引操作将值赋给一个变量，Rust 会尝试移动该值，从而导致所有权转移。

但是引用又不允许所有权转移，所以报错，把T加上 Copy 约束，这个特征表示类型 T 的值是可以被“复制”的，而不是移动的。对于实现了 Copy 特征的类型，Rust 在赋值时会自动执行浅拷贝，而不是移动所有权。

[zero-edge-code]

吊打java泛型擦除

[ramonli]

这泛型，头大

[atidat]

largest方法跑不过

let mut largest = arr[0];
| ^^^^^^
| |
| cannot move out of here
| move occurs because arr[_] has type T, which does not implement the Copy trait
| help: consider borrowing here: &arr[0]

 for &item in arr.iter() {
|         -----    ^^^^^^^^^^
|         ||
|         |data moved here
|         |move occurs because `item` has type `T`, which does not implement the `Copy` trait
|         help: consider removing the `&`: `item`

[Mysterious0o0]

官网是这么写的：

fn largest<T: std::cmp::PartialOrd> (list: &[T]) -> &T {
    let mut largest =  &list[0];
    for item in list.iter(){
        if item > largest {
            largest = item;
        }
    }
    largest
}

[liuhq]

要学会看错误，编译器已经告诉你了，是没有约束 Copy 的特征实现

|         |move occurs because `item` has type `T`, which does not implement the `Copy` trait
|         help: consider removing the `&`: `item`

[LXYan2333]

const泛型那里可以补充一下，N是可以直接在函数体里使用的。

fn display_array<T: std::fmt::Debug, const N: usize>(arr: [T; N]) {
    println!("{}",N)
}

[Boooooom030]

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

impl Point {
fn x(&self) -> &T {
&self.x
}
}

fn main() {
let p = Point { x: 5, y: 10 };

println!("p.x = {}", p.x());

请问一下在x方法中，为什么最后需要返回&T类型呢？本地尝试了取消引用，提示cannot move out of self.x which is behind a shared reference，并且还说T没有copy特征，但是之前不是说了&self相当于self:&Self吗，这么说我直接self.x返回的不就应该是&T类型吗，难道说rust自动解引用了所以需要再引用一次吗？同时，为什么不能返回T类型呢

[yuhao00]

你的示例代码没有泛型参数的声明。

&self的确是self : &Self，但是self.x代表的是(&Self).x，意味着通过引用拿出其成员，属于move。所有权规则不允许通过引用拿走所有权，要么你Copy一份自己玩去，原来那一份你动不了。

[yuhao00]

另外，&self.x的类型是&T，就是那个成员x的引用。先处理self.x，&是最后的。

[meifu2027]

我本来也纳闷呢，但是是不是稍微这样变一下就好理解了

struct Point {
    x: T,
    y: T,
}
// 原代码
impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}
// 等同于
impl<T> Point<T> {
    fn x(self: &Self) -> &T {
        &self.x
    }
}
// 是不是也可以这么理解？
impl<T> Point<T> {
    fn x(self: &Self) -> &T {
        &(self.x)
    }
}

[Lincest]

可以直接运行的largest方法, 加入PartialOrd 和 Copy的trait

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        {
            if item > largest {
                largest = item;
            }
        }
    }

    largest
}

[meimeitou]

Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue

这个真的是我现在就能看的代码吗？

上一步还是1+1=2，下一步就要解二元一次方程😂

[WenqingZong]

同感，Rust的语法实在是有点难懂。

[duanyuluo]

之前有个评论分析的很好，要用编译器的眼睛来审视代码 ：D

1. Assert: IsTrue
2. b => {true}
3. mem_size::() < 768 => true
   反着看，就容易理解了。

[duanyuluo]

我去，吃掉了《》符号
'''rust
Assert<{ core::mem::size_of::() < 768 }>: IsTrue
=>
const b: bool = core::mem::size_of::() < 768;
Assert: IsTrue
=>
let mem_of_T: usize = core::mem::size_of::();
const b: bool = mem_of_T < 768;
Assert: IsTrue
'''

[x931890193]

个人觉得、 习题还需要优化一下

[Jianjie96]

刚从2.8.2 特征 Trait章节回来，感觉rust中好像没有泛型约束或者说叫特征约束了?

[xiandaoyan]

fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
let mut largest = list[0];

for &item in list.iter() {
    if item > largest {
        largest = item;
    }
}

largest

}

这段代码在最新的rust 1.64版本上依然无法编译通过，请高手指点下呢，谢谢

[Boooooom030]

vsc报错很明显吧，在let mut largest = list[0]中 T没有约束copy特征

[endlesstravel]

所有权的问题？你是要从list中复制这个最大元素？还是从这个 list 中返回一个最大元素的引用之类的？
完善了下代码，如果不用clone的话，只能返回引用了

fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
    if list.len() == 0 {
        panic!("error size")
    }
    let mut largest = &list[0];
    for item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

[xiandaoyan]

感谢回复，我之前还没有学多特征约束，所以不知道后边可以+Copy，多谢@
Boooooom030

[xiandaoyan]

感谢回复，@endlesstravel你的方式返回引用没问题，多谢

[bamuwe]

已经开始昏头了

[Hello-world150]

同感

[xbsheng]

坚持就是胜利~

[drakedoglife]

有点迷糊这里

在《Const 泛型》习题中，实例2给出了const泛型参数使用的三个条件：

• 一个单独的const泛型参数
• 一个字面量 (i.e. 整数, 布尔值或字符)
• 一个具体的 const 表达式( 表达式中不能包含任何 泛型参数)
  示例代码入下：

fn foo<const N: usize>() {}

fn bar<T, const M: usize>() {
    foo::<M>(); // ok: 符合第一种
    foo::<2021>(); // ok: 符合第二种
    foo::<{20 * 100 + 20 * 10 + 1}>(); // ok: 符合第三种
    
    foo::<{ M + 1 }>(); // error: 违背第三种，const 表达式中不能有泛型参数 M
    foo::<{ std::mem::size_of::<T>() }>(); // error: 泛型表达式包含了泛型参数 T
    
    let _: [u8; M]; // ok: 符合第一种
    let _: [u8; std::mem::size_of::<T>()]; // error: 泛型表达式包含了泛型参数 T
}

fn main() {}

问题就来了：代码中foo::<{ std::mem::size_of::<T>() }>(); // error: 泛型表达式包含了泛型参数 T"这一句和教程中的Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue,这一句有什么区别吗？教程的例子不是也应该违背了条件3？

[alex-huang-real]

可能是要开启nightly版本的generic_const_exprs特性才行，我复制这段代码近IDE也是会提示报错
generic parameters may not be used in const operations
type parameters may not be used in const expressions

[drakedoglife]

确实，开启后不再报错，也就是说这种写法在stable版本中仍然不支持。

[Sword-Of-Code]

let buffer = Buffer:: {
data: [0; SIZE],
};
这种写法是语法糖吗？
let buffer: Buffer = Buffer {
data: [0; SIZE],
};
这样写能看的懂，上面也没介绍这种写法吧？还是我看漏了？

[Benxiaohai001]

泛型详解中的列子，加上比较运算属性也无法编译通过呀？我按照错误提示修改了下

fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T{
    let mut largest = &list[0];
    for item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}
fn main() {
    let number = vec![34, 50, 25, 100, 65];
    let result = largest(&number);
    println!("The largest number is {}", result);
    let char_list = vec!['y', 'm', 'a', 'q'];
    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

这样可以通过编译

[lyric-zemin]

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

为啥for循环时用 &item , if判断的时候用的 item , &item 是对 item变量解引用了吗？

[alex-huang-real]

Rust编译器内置了自动解引用的功能，在需要值的地方，提供引用会自动帮你解引用，功能类似于Deref这个Trait ### 错误的说法

[lyric-zemin]

但是我查看类型时发现 for循环时使用&item 类型为T, 使用 item类型为&T, 看起来就像&item 是对item变量解引用了

[alex-huang-real]

我查了一下，我前面说法是错误的。这里好像是用到了解构模式，item是T的

[shouriken]

先将上述代码修改为可以编译过的:

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

这里item和largest都是&T类型的；
也可以改成

for &item in list.iter() {
     if item > *largest {
        largest = item;
    }
}

这样的话item是T类型的, largest是&T类型的，不能直接比较，编译器会报错：

error[E0308]: mismatched types
  --> src/main.rs:25:19
   |
21 | fn largest<T: PartialOrd>(list: &[T]) -> &T {
   |            - expected this type parameter
...
25 |         if item > largest {
   |            ----   ^^^^^^^ expected type parameter `T`, found `&T`
   |            |
   |            expected because this is `T`
   |
   = note: expected type parameter `_`
                   found reference `&_`
help: consider dereferencing the borrow
   |
25 |         if item > *largest {
   |  

必须要通过解引用运算符*将largest的类型变成T才能比较。
比较运算符 <, >, '>='...其实是PartialOrdtrait的partial_cmp方法(可以在idea中点击大小于符号跳转,上面的两种代码中,>跳转的代码其实是不一样的)：

pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
   fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;
}

上一章->运算符到哪儿去了可以解释为什么T和&T两种类型都可以进行比较。

[rtransformation]

提个小建议，如果正文中能直接加上某些专有名词对应的英文就更好了，比如这一章中的“多态”，以后看英文资料的时候就能直接对应上了。

[kissme666]

wishtody, 这语法看一遍都脑壳疼

[shouriken]

在不支持泛型的编程语言中，通常需要为每一种类型编写一个函数

go: "please do not call me !"

[PPPPigggg]

我是看漏了哪章吗？

[a67793581]

非常棒~🎉

[yuzhiblue]

看教程不算难，但是一看习题1，直接懵了。和教程完全不搭，而且教程中关于单元结构体和元组结构体的描述一带而过，完全没想到这么多知识点。建议老师补充一下这一块。。。

[pinerge]

fn largest<T: PartialOrd<T> + Clone>(list: &[T]) -> T {
    let mut largest = &list[0];

    for item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    (*largest).clone()
}

fn main() {
    let number_list = vec![34, 50, 252, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'z', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

// cargo run
// The largest number is 252
// The largest char is z

[sheyifan]

在泛型参数之前，Rust 完全不适合复杂矩阵的运算，自从有了 const 泛型，一切即将改变

复杂矩阵的运算为什么不能使用切片引用？切片引用不是也有数组长度的信息吗？

[sheyifan]

单态化是静态分发，机制类似于C++的模板；Rust也有动态分发的机制（使用dyn），使用虚函数表的机制

[CaicoLeung]

Rust 中的 Const 泛型（Const Generics）

Const 泛型允许你用编译期常量值作为泛型参数，不只是类型。这让你可以在类型系统中携带数值信息。

---

基本语法

struct Array<T, const N: usize> {
    data: [T; N],
}

let a: Array<i32, 5> = Array { data: [1, 2, 3, 4, 5] };
let b: Array<i32, 3> = Array { data: [1, 2, 3] };
// a 和 b 是不同的类型！

const N: usize 就是一个 const 泛型参数，N 在编译期确定。

---

为什么需要它？

在 const 泛型出现之前，Rust 标准库对数组 [T; N] 的 trait 实现需要手动枚举每个长度（[T; 0]、[T; 1]、……、[T; 32]），非常丑陋。有了 const 泛型，可以一次性搞定：

impl<T: PartialEq, const N: usize> PartialEq for [T; N] {
    fn eq(&self, other: &Self) -> bool {
        self.iter().zip(other).all(|(a, b)| a == b)
    }
}

---

实用例子

1. 固定大小的矩阵

struct Matrix<const ROWS: usize, const COLS: usize> {
    data: [[f64; COLS]; ROWS],
}

impl<const R: usize, const C: usize> Matrix<R, C> {
    fn shape(&self) -> (usize, usize) {
        (R, C)
    }
}

// 编译器保证你不能把 3x4 的矩阵传给期望 4x3 的函数
fn transpose<const R: usize, const C: usize>(m: Matrix<R, C>) -> Matrix<C, R> { ... }

2. 编译期边界检查

struct Buffer<const CAP: usize> {
    data: [u8; CAP],
    len: usize,
}

impl<const CAP: usize> Buffer<CAP> {
    fn push(&mut self, byte: u8) {
        assert!(self.len < CAP, "Buffer overflow");
        self.data[self.len] = byte;
        self.len += 1;
    }
}

3. 函数中使用 const 泛型

fn first_n<T, const N: usize>(slice: &[T]) -> &[T; N] {
    slice[..N].try_into().unwrap()
}

let arr = [1, 2, 3, 4, 5];
let first: &[i32; 3] = first_n(&arr); // 返回类型携带了长度信息

---

Const 泛型表达式（nightly）

在稳定版中，const 泛型参数的使用有一些限制，不能直接写 N + 1 这样的表达式。nightly 的 #![feature(generic_const_exprs)] 可以解锁：

#![feature(generic_const_exprs)]

fn concat<T: Copy, const A: usize, const B: usize>(
    a: [T; A],
    b: [T; B],
) -> [T; A + B] {  // 编译期计算新长度
    // ...
}

---

限制（稳定版）

限制	说明
支持的类型	只能是整数、bool、char
不支持浮点	const N: f64 不合法
表达式受限	不能在类型位置写 N * 2（nightly 才支持）
不能用泛型类型	const N: T 不合法

---

核心思想总结

普通泛型：  Vec<T>       —— 对"类型"参数化
Const 泛型：[T; N]       —— 对"编译期常量值"参数化

Const 泛型本质上是把编译期已知的数值提升到类型系统中，让编译器在零运行时开销的情况下做更多的正确性保证。这在嵌入式、线性代数库（如 nalgebra）、协议编解码等场景中非常有价值。