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]

泛型会具化为不同类型

[roushanyyzz]

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

[palpink]

凡是要用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

[EXSPIRAVIT1104OFFICIAL]

Done.

[Grapeve]

Done

[AliceThunder]

DONE

[Bruce012356]

mark

[liaosunny123]

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

[killdayu]

重0开始第6个

[790228724]

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

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

[Coke-Code]

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

[Nixicodo]

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

[Nixicodo]

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

[F1shAndCat]

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

[zhouhaoan]

示例3：

   Compiling playground v0.0.1 (/playground)
error[E0599]: no function or associated item named `from_slice` found for struct `MinSlice` in the current scope
  --> src/main.rs:17:40
   |
1  | pub struct MinSlice<T, const N: usize> {
   | -------------------------------------- function or associated item `from_slice` not found for this struct
...
17 |     let minslice = MinSlice::<u8, 12>::from_slice(slice).unwrap();
   |                                        ^^^^^^^^^^ function or associated item not found in `MinSlice<u8, 12>`

For more information about this error, try `rustc --explain E0599`.
error: could not compile `playground` (bin "playground") due to previous error

不知道为什么这个代码框我还没法编辑，想改都不行

[michael1735]

我也是一样

[michael1735]

大佬，例子中的第三个好像没法通过编译

[wsj6109118105]

done

[Ghy0202]

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(S(A));          // 具体的类型
    gen_spec_t(SGen(A));   // 隐式地指定类型参数  `A`.
    gen_spec_i32(SGen(32)); // 隐式地指定类型参数,32可以替换成任意在i32范围内的数字

    // 显式地指定类型参数 `char`
    generic::<char>(SGen::<char>('c'));//注意显式的写法

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

2、泛型写一个函数

// 实现下面的泛型函数 sum
fn sum<T: std::ops::Add<Output = T>>(x:T,y:T)->T{
    x+y//这里函数头需要加一个特征，不然编译器会报错，至于为什么加这个，不清楚，因为写成<T>的时候编译器给的建议是改成现在这个<T: std::ops::Add<Output = T>>
}

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

3、泛型写一个结构体

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

4、结构体中泛型但是不同的类型

struct Point<T,S> {
    x: T,
    y: S,//看出来是两个不一样的泛型即可
}

fn main() {
    let p = Point{x: 5, y : "hello".to_string()};
}

5、impl中使用泛型

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

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


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

6、impl的函数中使用一种泛型，而impl对应的结构体使用一种泛型

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

impl<T, U> Point<T, U> {
    // 实现 mixup，不要修改其它代码！
    fn mixup<A,B>(self,other:Point<A,B>)->Point<T,B>{//注意这边，泛型类型如何保持一致性
        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, '中');
}

7、额，这个真是盲点了，改成泛型说是没有.powi的方法

结果这个标准答案和泛型不能说没有关系，只能说毫不相干🤣

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.0_f32, y: 10.0_f32};//把x和y的数据类型改成f32
    println!("{}",p.distance_from_origin())
}

[Ghy0202]

补充const 泛型的题目
const泛型练习

1、需要保持类型T和维度N一致

// 修复错误
struct Array<T, const N: usize> {
    data : [T; N]
}

fn main() {
    let arrays = [
        Array{
            data: [1, 2, 3],
        },
        Array {
            data: [1, 2, 3],
        },
        Array {
            data: [1, 2,3]
        }
    ];
}

2、打印const泛型

// 填空
fn print_array<T:std::fmt::Debug,const N: usize>(arr:[T;N]) {
    println!("{:?}", arr);
}
fn main() {
    let arr = [1, 2, 3];
    print_array(arr);

    let arr = ["hello", "world"];
    print_array(arr);//因为这里没有切片，所以函数体声明的时候不要加切片
}

3、其实也可以不同计算占用的空间

#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

fn check_size<T>(val: T)
where
    Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue,
{
    //...
}

// 修复 main 函数中的错误
fn main() {
    check_size([0u8; 767]); 
    check_size([0i32; 191]);
    check_size(["hello你好"; 1]); // size of &str ?
    check_size([(); 1].map(|_| "hello你好".to_string()));  // size of String?
    check_size(['中'; 1]); // size of char ?
}



pub enum Assert<const CHECK: bool> {}

pub trait IsTrue {}

impl IsTrue for Assert<true> {}

[zx-81-16k]

Task 1. What is the target ? Where can i read about it ?
Task 2. Task description is wrong or i don't understand something

[tjw123hh]

第7题好像不用f32标记也能通过

[chenhai998]

done

[Desjajja]

尝试实现了一下example 3当中的MinSlice::from_slice：

impl<T: Default + Copy, const N: usize> MinSlice<T, N> {
    fn from_slice(slice: &[T]) -> Option<Self> {
        if slice.len() < N {
            None
        } else {
            let (head, _) = slice.split_at(N);
            let mut res_head = [T::default(); N];
            for i in 0..N {
                res_head[i] = head[i]
            }
                Some(Self{head: res_head})

        }
    }
}

playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=e5e7b5ecba41648cc4a6535ce45ba521
用到了下一节才讲的traits，有点超纲，大家看看有没有更好的实现方法。

[Desjajja]

impl<T: Copy, const N: usize> MinSlice<T, N> {
    fn from_slice(slice: &[T]) -> Option<Self> {
        if slice.len() < N {
            None
        } else {
            Some(Self{head: (&slice[..N]).try_into().ok()?})

        }
    }
}

[Desjajja]

inspired by @hexsix

[hexsix]

Rust 不支持元素类型不同的数组。

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

如果你确实需要实现类似于上述代码的效果，可以考虑 enum 或者 Box 来实现伪泛型的效果

enum:

#[derive(Debug)]
enum Data {
    Ints(Vec<i32>),
    Floats(Vec<f64>),
}

#[derive(Debug)]
struct Array {
    data: Data,
}

fn main() {
    let arrays = vec![
        Array {
            data: Data::Ints(vec![1, 2, 3]),
        },
        Array {
            data: Data::Floats(vec![1.0, 2.0, 3.0]),
        },
        Array {
            data: Data::Ints(vec![1, 2]),
        }
    ];
    println!("{:?}", arrays);
}
// Output: [Array { data: Ints([1, 2, 3]) }, Array { data: Floats([1.0, 2.0, 3.0]) }, Array { data: Ints([1, 2]) }]

Box:

use std::any::Any;

#[derive(Debug)]
struct Array {
    data: Box<dyn Any>,
}

fn main() {
    let arrays = vec![
        Array {
            data: Box::new(vec![1, 2, 3]),
        },
        Array {
            data: Box::new(vec![1.0, 2.0, 3.0]),
        },
        Array {
            data: Box::new(vec!["a", "b", "c"]), 
        }
    ];
    println!("{:?}", arrays);
}
// Output: [Array { data: Any { .. } }, Array { data: Any { .. } }, Array { data: Any { .. } }]

[YongxinCao12138]

第六题为什么self参数不用&self

[BokutoMan]

DOWN

[felipe300]

• done

[aardwolfchen]

请教下 Assert<{ core::mem::size_of::() < 768 }>: IsTrue,
中
core::mem::size_of::()如果是编译时运行的，那它时是怎么运行的？

[DylanJinx]

done~~~

[DylanJinx]

最后一题个人理解：
core::mem::size_of::<T>() < 768：是指最多占内存767bytes；

• 一个u8类型占1byte，而数组[0u8; x]中的x是个数，所以x最大是767；
• i32类型占4bytes，767/4 = 191.75取191；
• "hello你好"是&str类型，在具体的体系结构上，如 x86-64，一个 word（字）通常是 64 位，也就是 8 字节。在这样的系统中，&str 类型通常占用两个 word：指针、长度。 这样的布局意味着不论字符串实际上有多长，&str 类型的变量本身总是占用 16 字节（在 64 位系统中，因为两个 word 总共是 16 字节）。767/16=47.9375取47；
• "hello你好".to_string()是String类型，但是有三个字段：指针、长度、容量，每个占8bytes，总共24bytes，767/24=31.953取31。