generics-traits/const-generics

[giscus[bot]]

generics-traits/const-generics

Learning Rust By Practice, narrowing the gap between beginner and skilled-dev with challenging examples, exercises and projects.

https://zh.practice.rs/generics-traits/const-generics.html

[einQimiaozi]

您好，练习3的题解是不是有错误，check_size无法传入String类型，因为要求String类型实现copy trait，题解中的答案会报错，需要传入String的引用好像才可以通过编译

[sunface]

我看看哈，你可以顺便提个 PR :P

[mrxiaozhuox]

我不理解，第一题的题解有什么意义呢。（似乎并不是真正解决问题）

[sunface]

第一题往往用于熟悉概念，这里的目的亦是如此

[sicheng1806]

泛型会具化为不同类型

[bajfi]

Tuple may be better
fn main() {
let arrays = (
Array{
data: [1, 2, 3],
},
Array {
data: [1.0, 2.0, 3.0],
},
Array {
data: [1, 2]
}
);
}

[ZYKWLJ]

智齿作者大大！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

[roushanyyzz]

第三题报错
#![feature] may not be used on the stable release channel

[yejunjin]

凡是要用std库feature的，都要用nightly编译。cargo +nightly

[Altriaww]

Done

[makexiao113]

done！请问第七题得sqrt方法要T实现什么trait？
// 修复错误，让代码工作
struct Point {
x: T,
y: T,
}

impl Point {
fn distance_from_origin(&self) -> T
where
T: std::ops::Mul<Output = T> + std::ops::Add<Output = T>,
{
(self.x * self.x + self.y * self.y).sqrt()
}
}

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

[mathisxx]

不是很理解，第三题

pub enum Assert {} 这个枚举中，CHECK是一个const 泛型
它在fn check_size(val: T)
where
Assert<{ core::mem::size_of::() < 768 }>: IsTrue,
{
//...
}
中是 core::mem::size_of::() < 768 这个表达式，按照此节开头的说法，const泛型在使用时必须为常量或常量表达式，也就是在编译时可以确定的字面值。不明白第三题这样使用为何没有错误

[ghost]

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

大括号里边是一个表达式，返回一个bool，当返回false的时候，也就是Assert<false>，而上边这行要求实现IsTrue这个Trait，然而只当是true的时候才实现了，所以不满足。
这样通过Trait的方式可以在编译期保证，而不是运行时检查。
你问的const 并没有 在上边这行里，他在下边呢：

pub enum Assert<const CHECK: bool> {}

这里的确实是编译期确定的，因为rust编译器通过单态化为程序所有的可能情况都计算出了确定的值，到底是true还是false
这是我个人浅显的理解...

[ghost]

这样的写法我认为有一个隐含的要求：传入的类型必须是 编译期已知 大小的

[ghost]

找到原因了……
#![allow(incomplete_features)]
#![feature(generic_const_exprs)]
这里！

[colorsu]

第一题怎么理解呢？直接用类型调用函数？我从c/c++语言的角度来看，不是要先定义一个变量或者参数，然后传给函数作为形参吗？那这里这样调用函数 reg_fn(S(A)) 是什么意思呢？最终是什么都没干吗？编译器怎么生成代码的这里。
struct A; // Concrete type A.
struct S(A); // Concrete type S.
fn reg_fn(_s: S) {}
fn main() {
// Using the non-generic functions
reg_fn(S(A)); // Concrete type.
}

[ghost]

调用的时候实例化了吧。比如：

reg_fn(S(A));

我认为这一行等价于：

let temp_a = A; // 实例化A
let temp_s = S(temp_a); // 实例化S
// 调用
reg_fn(temp_s);

题目中的：

reg_fn(S(A));

是其简化写法吧，因为这个实例在后边并不需要，只需要在这个函数使用一次。就不需要在用 let 来绑定了吧。
确实什么也没做，因为函数体是空的。
这个题只是在说 类型要符合函数签名 吧？

[ddxiaoming]

感觉语法好乱，记不住

[matyle]

done1

[haochen-zeng]

Done.

[Grapeve]

Done

[AliceThunder]

DONE

[Bruce012356]

mark

[liaosunny123]

第三题的:我们知道 .get 返回的是 Some(b' ')是什么意思？为什么返回的是' '

[killdayu]

重0开始第6个

[crypto-le]

🌟🌟 <T, const N: usize> 是结构体类型的一部分，和数组类型一样，这意味着长度不同会导致类型不同： Array<i32, 3> 和 Array<i32, 4> 是不同的类型

第一题：我理解的知识点是：数组每一个元素类型都要一样，如果第一个元素是[i32,3] 第二个是[i32,4] 就没法 在外面使用[]来表达 错误示范：[[i32,3],[i32,4]]

[Coke-Code]

第三题的限制大小size是怎么算的，比如0u8对应的767？没有强类型语言经验的小白看得很懵

[Sagecheni]

得先看上面的check_size函数：Assert<{ core::mem::size_of::() < 768 }>: IsTrue,
要求占用的大小要<768，然后就根据每个类型占用的大小和768-1进行计算，比如u8占1个字节，所以u8数组的长度就得<768，其他的同理

[Nixicodo]

看评论区吐槽的第三题貌似和现在看到的不一样啊，是更换题目了吗

[Nixicodo]

哦，原来是泛型和const泛型两部分习题共用一个评论区……

[F1shAndCat]

第三题描述改成取极限大小会好点吗 我做的时候直接用3个1水过去了

[SandyLi0404]

done

[TDAkory]

mark finished

[flyingsand]

第六题mixup里为什么用self程序就可以通过，而用&self则通过不了

[vhtmui]

方法的参数&self实际上是self: &Self的语法糖，你传入一个引用，并在函数内获取self.x这个值的所有权（没实现copy会发生move）。但你传入的引用并没有self变量本身的所有权。

[Deusvult6764]

Mixup was a little technical for me.

[yomanthunder]

that was kinda tough , but i understood a lot of concept from that example

[Blyzes]

done 但还没理解明白

[yomanthunder]

Good one there ,
Done !!

[justin-z0]

难度大大增加了，跟不上了 😄

[zhengkezhou1]

day4 完成范型

[zhengkezhou1]

day4 完成范型内容

[bansal-harsh-2504]

Done ✅
day 8

[TajangSec]

并不简单！

[gastrodia]

这个第7题。我怎么写都报错。我打开答案一看，我真的想笑....
根本不是我想要的答案啊

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

impl<T> Point<T>
where
    T: std::ops::Add<Output = T>,
    T: std::ops::Mul<Output = T>,
    T: Copy,
    T: Into<f32>,
{
    fn distance_from_origin(&self) -> f32 {
        let x = self.x.into();
        let y = self.y.into();
        (x.powi(2) + y.powi(2)).sqrt()
    }
}

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

我觉得我这个答案更好，只是会报错

the trait bound f32: From<i32> is not satisfied

查了下，
是因为整数类型不能直接转成f32，转换到 f32 可能会损失精度,所以 Rust 不提供直接的 From/Into 实现
所以把f32改成f64就好了

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

impl <T>Point<T>
where
    T: std::ops::Add<Output = T>,
    T: std::ops::Mul<Output = T>,
    T: Copy,
    T: Into<f64>,
{
    fn distance_from_origin(&self) -> f64 {
        let x = self.x.into();
        let y = self.y.into();
        (x.powi(2) + y.powi(2)).sqrt()
    }
}

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

人在无语的时候真的会笑，当看到参考答案的时候🙂

[happyfeetw]

哈哈哈哈哈哈

[happyfeetw]

关于const generic部分的第三题有个问题。
在stable版本执行代码时，编译器会提示：

error[E0554]: `#![feature]` may not be used on the stable release channel
 --> src/main.rs:2:1
  |
2 | #![feature(generic_const_exprs)]
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

查了一下原因，发现是题干里使用的#![feature(generic_const_exprs)]特性已经在最新的（目前是1.84.1）稳定版中被移除了.

对于各位贴代码到本地ide中运行的同学，有两个方案可以解决这个问题：

• 下载安装并切换到nightly版本的rust来run；
• 下载nightly后不作切换，仅使用cargo +nightly run命令

我猜这里应该是想综合考察前面关于类型大小的知识点？不知道作者大大是怎么考虑的。我稍后会提交一个pr，针对当前1.84版本做一个修复，请参考。

[happyfeetw]

最后一段请忽略

[HenryLunaAdam]

done.

[loogn]

第六题：

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