【Rust学习日志】2024.03.30

[Irissssaa]

特征Trait

• format! 是 Rust 标准库提供的一个宏，用于将数据格式化成字符串。通过 format! 宏，你可以根据指定的格式将不同类型的数据转换为字符串并进行拼接。下面是一个简单的例子，展示了如何使用 format! 宏将不同类型的数据格式化成字符串：

fn main() {
    let name = "Alice";
    let age = 30;
    let height = 1.75;

    // 使用 format! 宏将数据格式化成字符串
    let formatted_string = format!("Name: {}, Age: {}, Height: {}", name, age, height);
    
    println!("{}", formatted_string);
}

​ 在这个例子中，我们使用 format! 宏将 name（字 符串）、age（整数）和 height（浮点数）格式 化成一个字符串，并将结果打印到控制台上。

​ format! 宏的语法类似于字符串插值，你可以在字 符串中使用 {} 占位符来表示需要插入的数据。在 format! 宏中，占位符 {} 会依次被后面的参数 替换，最终形成一个完整的字符串。

• #[derive(PartialEq, PartialOrd)] 用于自动为结构体或枚举类型实现 PartialEq 和 PartialOrd 这两个 trait。

  • PartialEq 用于比较两个值是否相等。
  • PartialOrd 用于比较两个值的大小关系，但是并不要求完全的顺序关系。

• 在 Rust 中重载运算符，通常需要使用 std::ops 模块中提供的特征来实现相应的运算符行为。std::ops 模块定义了一系列 trait，用于支持运算符重载和自定义类型的操作。通过实现这些 trait，可以为自定义类型定义运算符的行为，从而使代码更具表达力和灵活性。

   use std::ops;
   // 实现 fn multiply 方法
   // 如上所述，`+` 需要 `T` 类型实现 `std::ops::Add` 特征
   
   fn multiply<T: ops::Mul<Output=T>>(a:T, b:T) ->T {
       a*b
   }
   
   fn main() {
       assert_eq!(6, multiply(2u8, 3u8));
       assert_eq!(5.0, multiply(1.0, 5.0));
   
       println!("Success!")
   }

• impl ops::Add<Bar> for Foo 表示为类型 Foo 实现了 ops::Add trait 的特定实现，使得可以对类型 Foo 和 Bar 进行加法操作。具体来说，这个语法表示为类型 Foo 实现了加法操作符 + 的行为，其中加数的类型是 Bar。

   use std::ops;
   struct Foo;
   struct Bar;
   //虽然代码中没有直接使用到 Debug trait，但是实现它们是一个良好的习惯，可以提高代码的可读性和可维护性。这种做法也符合 Rust 社区的惯例和推荐标准。
   #[derive(PartialEq,Debug)]
   struct FooBar;
   
   #[derive(PartialEq,Debug)]
   struct BarFoo;
   
   // 下面的代码实现了自定义类型的相加： Foo + Bar = FooBar
   //值的注意的是要对Foo和Bar都实现Add和Sub
   impl ops::Add<Bar> for Foo {
       type Output = FooBar;
   
       fn add(self, _rhs: Bar) -> FooBar {
           FooBar
       }
   }
   impl ops::Add<Foo> for Bar {
       type Output = FooBar;
   
       fn add(self, _rhs: Foo) -> FooBar {
           FooBar
       }
   }
   
   
   impl ops::Sub<Foo> for Bar {
       type Output = BarFoo;
   
       fn sub(self, _rhs: Foo) -> BarFoo {
           BarFoo
       }
   }
   impl ops::Sub<Bar> for Foo {
       type Output = BarFoo;
   
       fn sub(self, _rhs: Bar) -> BarFoo {
           BarFoo
       }
   }
   
   fn main() {
       assert_eq!(Foo + Bar, FooBar);
       assert_eq!(Foo - Bar, BarFoo);
   
       println!("Success!")
   }

• 使用特征作为函数参数：除了使用具体类型来作为函数参数，我们还能通过 impl Trait 的方式来指定实现了该特征的参数：该参数能接受的类型必须要实现指定的特征。

   //首先自定义一个特征
   trait Summary {
       fn summarize(&self) -> String;
   }
   
   #[derive(Debug)]
   struct Post {
       title: String,
       author: String,
       content: String,
   }
   //然后对类型实现该特征
   impl Summary for Post {
       fn summarize(&self) -> String {
           format!("The author of post {} is {}", self.title, self.author)
       }
   }
   
   fn main() {
       let post = Post {
           title: "Popular Rust".to_string(),
           author: "Sunface".to_string(),
           content: "Rust is awesome!".to_string(),
       };
       
       summary(&post);
   //这里使用了一个函数，使用该函数的要求就是参数必须实现了Summary特征  
       println!("{:?}",post);
   //上面使用函数时没有移走参数的所有权
   }
   
   // 在下面定义 `fn summary` 函数
   fn summary(item: &impl Summary) {
       println!("{:?}",item.summarize())
   }

• 使用特征作为函数返回值：可以在函数的返回值中使用 impl Trait 语法。然而只有在返回值是同一个类型时，才能这么使用，如果返回值是不同的类型，你可以使用特征对象。

   struct Sheep {}
   struct Cow {}
   
   trait Animal {
       fn noise(&self) -> String;
   }
   
   impl Animal for Sheep {
       fn noise(&self) -> String {
           "baaaaah!".to_string()
       }
   }
   
   impl Animal for Cow {
       fn noise(&self) -> String {
           "moooooo!".to_string()
       }
   }
   
   // 返回一个类型，该类型实现了 Animal 特征，但是我们并不能在编译期获知具体返回了哪个类型
   /*
   fn random_animal(random_number: f64) -> impl Animal {
       if random_number < 0.5 {
           Sheep {}
       } else {
           Cow {}
       }
   }
   可以使用特征对象，如下：*/
   fn random_animal(random_number: f64) -> Box<dyn Animal> {
       if random_number < 0.5 {
           Box::new(Sheep {})
       } else {
           Box::new(Cow {})
       }
   }
   //对于Box的使用会在下一条解释
   fn main() {
       let random_number = 0.234;
       let animal = random_animal(random_number);
       println!("You've randomly chosen an animal, and it says {}", animal.noise());
   }

• 继上一条示例，做以下补充：

  • 首先了解一下在 Rust 中，数据存储在栈上和堆上的一些区别：

    1. 栈上存储：

       • 栈上的数据有固定大小，大小在编译时必须是已知的。

       • 栈上的数据的生命周期由作用域（scope）决定，当变量离开作用域时，数据会被自动销毁。

       • 栈上的数据的分配和释放速度比堆上更快。

    2. 堆上存储：

       • 堆上的数据允许动态分配，其大小可以在运行时确定。

       • 堆上的数据的生命周期不受作用域限制，需要手动管理内存并显式释放以避免内存泄漏。

       • 堆上的数据的分配和释放速度相对较慢，因为需要动态分配和释放内存。

  • 了解完两个的区别后，下面将介绍Box ：

    在 Rust 中，Box 是一个智能指针类型，它允许将数据分配在堆上而不是栈上，并提供所有权转移和自动内存管理功能。实际上，Box 是一个包含堆上数据的指针，它有以下特点：

    1. 堆分配： Box 允许在堆上分配数据，这使得数据的大小可以在运行时动态确定，而不需要在编译时知道。这对于需要动态大小的数据结构非常有用。
    2. 所有权转移： Box 允许在所有者之间传递值的所有权。通过将值放入 Box 中，可以将所有权从一个所有者转移到另一个所有者，从而避免多个所有者或悬垂指针的问题。
    3. 自动释放： 当 Box 指针超出其作用域时，指向的堆上数据会被自动释放。这意味着不需要手动管理内存，避免了内存泄漏和悬垂指针问题。

    总之，Box 提供了一种安全且方便的方式来处理堆上分配的数据，同时遵循 Rust 的所有权规则。通过 Box，可以在 Rust 中轻松地进行堆分配和内存管理，而无需担心内存安全性问题。

  • 现在我们在来根据上一个示例对Box<dyn Animal> 和Box::new(Sheep {}) 做解释：

    • 当你定义一个 trait 时，实际上并不知道所有可能实现该 trait 的类型。在 Rust 中，编译器需要在编译时确定每个值的大小，但是对于具体类型未知的 trait 实现，编译器无法准确计算大小。

      为了解决这个问题，Rust 提供了 trait 对象来处理未知大小的类型。在这种情况下，你可以使用 Box<dyn Trait> 来创建一个指向实现了特定 trait 的类型的堆分配对象的指针。这允许在运行时根据具体情况来确定对象的大小。

      在示例中，Box<dyn Animal> 是一个 trait 对象，它表示一个实现了 Animal trait 的对象，但具体类型是在运行时确定的。通过将实例放入 Box 中，你可以在堆上分配空间以存储任意大小的对象，然后通过指针进行引用。

      总之，Box<dyn Trait> 是 Rust 中一种处理动态大小类型的常见方式，使得在编译时无法确定具体类型的情况下依然可以安全地操作这些类型。

      （再做一个小补充：在 Rust 中，dyn 关键字用于指示 trait 对象。当你定义一个==trait对象== 时，需要在 trait 的名称前加上 dyn 关键字，以明确表明这是一个动态大小的 trait 对象。）

    • Box::new(...)：这是一个 Rust 中用于在堆上分配内存并将值装箱的函数。通过调用 Box::new()，我们可以把一个值放到堆上而不是栈上，并返回一个指向堆上数据的 Box 智能指针。

•   use std::ops;
    fn main() {
    	assert_eq!(sum(1, 2), 3);
    }
    
    // 通过两种方法使用特征约束来实现 `fn sum`
    
    fn sum<T: Add<Output = T>>(x: T, y: T) -> T {
        x + y
    }
    
    fn sum<T>(x: T, y: T) ->T
    where
    T: Add<Output = T>,
    {
    	x + y
    }
    

• 在 Rust 中，使用 use 关键字可以将特定的模块、特性、结构体或枚举引入当前作用域，以便在代码中直接使用，而无需使用完整的路径来引用它们。这样可以使代码更加简洁和易读。

  • 当你需要在代码中直接使用某个特性（trait）时，比如 Add，你可以使用 use std::ops::Add; 将其引入到当前作用域，这样就可以直接在代码中使用 Add 而不需要写完整的路径。
  • 如果你希望一次性引入 std::ops 模块中的所有内容，你可以使用 use std::ops::*;，或者use std::ops;这样就可以在代码中直接使用该模块下的所有内容，而不需要逐一引入。

• 好好理解下面这段代码，以明白包闭

   fn example() {
       // `T: Trait` 是最常使用的方式
       // `T: Fn(u32) -> u32` 说明 `T` 只能接收闭包类型的参数
       struct Cacher<T: Fn(u32) -> u32> {
           calculation: T,
           value: Option<u32>,
       }
   
       impl<T: Fn(u32) -> u32> Cacher<T> {
           fn new(calculation: T) -> Cacher<T> {
               Cacher {
                   calculation,
                   value: None,
               }
           }
   
           fn value(&mut self, arg: u32) -> u32 {
               match self.value {
                   Some(v) => v,
                   None => {
                       let v = (self.calculation)(arg);
                       self.value = Some(v);
                       //这里已经将value传入了值，而不再是None
                       v
                   },
               }
           }
       }
   
       let mut cacher = Cacher::new(|x| x+1);
       assert_eq!(cacher.value(10), 11);
       assert_eq!(cacher.value(15), 11);
   }

  闭包（Closure）是一种可以捕获其环境中变量的匿名函数。闭包提供了一种方便的方式来操作数据，尤其适合用于需要在函数之间传递的逻辑代码块。下面是一个简单的例子来说明闭包的概念：

   fn main() {
       let num = 5;
       
       // 匿名函数示例
       let add_num = |x: i32| x + num; // 这是一个闭包，捕获了外部变量 num
       let result = add_num(3);
       assert_eq!(result, 8);
       
       // 使用标准函数定义的闭包
       let num = 10;
       let add_num_fn = |x| { // FnMut
           num + x
       };
       let result_fn = add_num_fn(3);
       assert_eq!(result_fn, 13);
   }

浅浅来个小补充

• to_uppercase() 和 .chars().last().unwrap() 是用于处理字符串的 Rust 方法。
  • to_uppercase(): 这是一个字符串方法，用于将字符串中的所有字符转换为大写形式。例如，对于字符串 "hello, world" 调用 to_uppercase() 后会得到 "HELLO, WORLD"。
  • .chars().last().unwrap(): 这是一个用于获取字符串最后一个字符的方法序列。首先，.chars() 将字符串转换为字符迭代器，然后.last() 获取迭代器中的最后一个元素（即最后一个字符），最后的.unwrap() 用于获取可能存在的最后一个字符，如果不存在则引发 panic。

特征对象

• 在 Rust 中，trait objects 默认是不允许调用具体类型（例如 Duck 或 Swan）的方法的，因为在编译时编译器无法确定 trait object 所指向的具体类型是什么。所以当我们使用 trait object 时，==编译器会擦除具体类型的方法==，因此无法直接调用具体类型的方法。这是为了确保在运行时能够安全地使用 trait object。

   trait Bird {
       fn quack(&self) -> String;
   }
   
   struct Duck;
   impl Duck {
       fn swim(&self) {
           println!("Look, the duck is swimming")
       }
   }
   struct Swan;
   impl Swan {
       fn fly(&self) {
           println!("Look, the duck.. oh sorry, the swan is flying")
       }
   }
   
   impl Bird for Duck {
       fn quack(&self) -> String{
           "duck duck".to_string()
       }
   }
   
   impl Bird for Swan {
       fn quack(&self) -> String{
           "swan swan".to_string()
       }
   }
   
   fn main() {
       let duck = Duck;
       duck.swim();
   
       let bird = hatch_a_bird(2);
       // 变成鸟儿后，它忘记了如何游，因此以下代码会报错
       // bird.swim();
       // 但它依然可以叫唤
       assert_eq!(bird.quack(), "duck duck");
   
       let bird = hatch_a_bird(1);
       // 这只鸟儿忘了如何飞翔，因此以下代码会报错
       // bird.fly();
       // 但它也可以叫唤
       assert_eq!(bird.quack(), "swan swan");
   
       println!("Success!")
   }   
   
   // 实现以下函数
   fn hatch_a_bird(n:i32) -> Box<dyn Bird>{
       match n {
           1 => Box::new(Swan),
           2 => Box::new(Duck),
           _ => panic!("无效鸟型")
       }
   }

•   trait Foo {
        fn method(&self) -> String;
    }
    
    impl Foo for u8 {
        fn method(&self) -> String { format!("u8: {}", *self) }
    }
    
    impl Foo for String {
        fn method(&self) -> String { format!("string: {}", *self) }
    }
    
    // 通过泛型实现以下函数
    fn static_dispatch<T: Foo>(x: T) -> String {
        x.method()
    }
    
    // 通过特征对象实现以下函数
    fn dynamic_dispatch(x: &dyn Foo) -> String {
        x.method()
    }
    
    fn main() {
        let x = 5u8;
        let y = "Hello".to_string();
    
        static_dispatch(x);
        dynamic_dispatch(&y);
    
        println!("Success!")
    }

• 了解静态分发（Box <T>）和动态分发(Box<dyn trait> 或&dyn trait)的用法

  因为泛型也是一种具体的类型，所以是静态分发

   trait Foo {
       fn method(&self) -> String;
   }
   
   impl Foo for u8 {
       fn method(&self) -> String { format!("u8: {}", *self) }
   }
   
   impl Foo for String {
       fn method(&self) -> String { format!("string: {}", *self) }
   }
   
   // 通过泛型实现以下函数
   fn static_dispatch<T: Foo>(x: T) -> String {
       x.method()
   }
   
   // 通过特征对象实现以下函数
   fn dynamic_dispatch(x: &dyn Foo) -> String {
       x.method()
   }
   
   fn main() {
       let x = 5u8;
       let y = "Hello".to_string();
   
       static_dispatch(x);
       dynamic_dispatch(&y);
   
       println!("Success!")
   }

• 对象安全：一个特征能变成特征对象，首先该特征必须是对象安全的，即该特征的所有方法都必须拥有以下特点：

  • 返回类型不能是 Self.
  • 不能使用泛型参数

   // 使用至少两种方法让代码工作
   // 不要添加/删除任何代码行
   trait MyTrait {
       fn f(&self) -> Self;
   }
   
   impl MyTrait for u32 {
       fn f(&self) -> Self { 42 }
   }
   
   impl MyTrait for String {
       fn f(&self) -> Self { self.clone() }
   }
   
   fn my_function(x: Box<dyn MyTrait>)  {
       x.f()
   }
   //函数修改为：
   //fn my_function<T: MyTrait>(x: Box<T>) ->T{
   //x.f()
   //}
   fn main() {
       my_function(Box::new(13_u32));
       my_function(Box::new(String::from("abc")));
   
       println!("Success!")
   }