【Rust学习日志】2024.03.16

[Irissssaa]

方法 Method

• 在 Rust 中，使用 . 调用的情况是针对一个具体的实例，用来调用该实例的方法或访问其字段。例如，如果有一个结构体实例 my_struct，可以使用 my_struct.method() 或 my_struct.field 来调用实例的方法或访问其字段。

  而使用 :: 调用的情况则通常是用来从一个类型或模块中访问关联函数、常量或嵌套类型。比如，可以使用 String::from("hello") 来调用 String 类型的关联函数 from，或者使用 std::cmp::min(3, 5) 来调用 std::cmp 模块中的 min 函数。

  总结起来，在 Rust 中使用 . 调用是针对实例的方法和字段，而使用 :: 调用则是针对类型、模块及其关联函数、常量和嵌套类型的访问。

泛型和特征

泛型Generics

• 当使用 #[derive(Debug)] 注解为自定义的结构体或枚举类型派生 Debug trait 时，编译器会自动为该类型生成实现了 std::fmt::Debug 的代码，因此就不需要手动实现 Debug trait 或者通过 impl Debug for YourType 的方式来限定。

•   // 实现下面的泛型函数 sum
    fn sum<T: std::ops::Add<Output = T>>(a:T, b:T)-> T{
        a+b
    }//在使用泛型前需要声明，如此处的sum<T>
    
    fn main() {
        assert_eq!(5, sum(2i8, 3i8));
        assert_eq!(50, sum(20, 30));
        assert_eq!(2.46, sum(1.23, 1.23));
    }

•   struct Point<T> {
        x: T,
        y: T,
    }
    
    fn main() {
        let p = Point{x: 5, y : "hello".to_string()};
    }//这串代码是不正确的
    //原因如下：在结构体中，同一泛型字段只能储存相同类型的值，此处x，y均是泛型T，则在赋值时因赋上相同类型的值
    //修改方式可为：
    struct Point<T，U> {
        x: T,
        y: U,
    }
    
    fn main() {
        let p = Point{x: 5, y : "hello".to_string()};
    }

•   struct Point<T> {
        x: T,
        y: T,
    }
    
    impl<T> Point<T> {
        fn x(&self) -> &T {
            &self.x
        }
    }//使用泛型参数前，依然需要提前声明：impl<T>，只有提前声明了，我们才能在Point<T>中使用它，这样 Rust 就知道 Point 的尖括号中的类型是泛型而不是具体类型。需要注意的是，这里的 Point<T> 不再是泛型声明，而是一个完整的结构体类型，因为我们定义的结构体就是 Point<T> 而不再是 Point。
    
    fn main() {
        let p = Point { x: 5, y: 10 };
    
        println!("p.x = {}", p.x());
    }

•   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 };
        let p2 = Point { x: "Hello", y: '中'};
    
        let p3 = p1.mixup(p2);
    
        assert_eq!(p3.x, 5);
        assert_eq!(p3.y, '中');
    }

• 在 Rust 中，数组是一个固定大小的数据结构，它要求所有元素都具有相同的类型。这是因为在编译时，编译器需要知道每个元素在内存中所占的空间大小，以便正确地分配和访问数组的元素。

•   fn print_array<T: std::fmt::Debug, const N:usize>(arr:[T;N]) {
        println!("{:?}", arr);
    }
    //要想按数组格式print，就需要对array实现`Debug` trait

关于打印的重要知识

1. 关于{} {:?} {:#?} 的使用场景

   • {} :是最常用的占位符，用于输出实现了std::fmt::Display trait 的类型，大多数内建类型（比如整型，浮点型，字符串等）都实现了Display trait ，因此可以直接使用{} 进行格式化输出；

   • {:?} :这个占位符用于实现了std::fmt::Debug trait 的类型，它会以调试格式打印类型的值，通常用于调试目的，如果你想查看更多关于类型的信息，包括类型名称和字段名，可以使用{:?} ;

   • {:#?} :这个占位符也用于输出实现了 std::fmt::Debug trait 的类型，但会以更美观的形式打印出来，每个字段占一行，适合复杂类型的调试输出。
     例子如下：

      #[derive(Debug)]
      struct Person {
          name: String,
          age: u32,
      }
      
      fn main() {
          let name = "Alice";
          let age = 25;
          println!("Name: {}, Age: {}", name, age);
      
          let person = Person {
              name: String::from("Bob"),
              age: 30,
          };
          
          println!("Person: {:?}", person);
          println!("Person (pretty): {:#?}", person);
      }
      /*Name: Alice, Age: 25
      Person: Person { name: "Bob", age: 30 }
      Person (pretty): Person {
          name: "Bob",
          age: 30,
      }*/

2. 常见的实现std::fmt::Debug trait 的方式

   • 派生宏：对于简单的结构体和枚举，你可以通过 #[derive(Debug)] 注解来自动实现 Debug trait。这样编译器会自动生成默认的调试输出格式。示例代码如下：

      #[derive(Debug)]
      struct MyStruct {
          field1: i32,
          field2: String,
      }
      
      #[derive(Debug)]
      enum MyEnum {
          Variant1,
          Variant2(i32, String),
      }
      

   • 手动实现：对于更复杂的类型，你可能需要手动实现 Debug trait 来定义自定义的调试输出格式。你可以在类型的 impl 块中实现 Debug trait 的 fmt 方法。示例代码如下：

   use std::fmt;
   struct MyStruct {
       field1: i32,
       field2: String,
   }
   
   impl fmt::Debug for MyStruct {
       fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
           write!(f, "MyStruct {{ field1: {}, field2: {} }}", self.field1, self.field2)
       }
   }

   当手动实现 std::fmt::Debug trait 时，我们需要在类型的 impl 块中定义 fmt 方法，该方法接收一个 &mut fmt::Formatter 参数，并返回 fmt::Result，下面是对例子的详细解释：

   • 首先，我们定义了一个结构体 MyStruct，其中包含两个字段：field1（类型为 i32）和 field2（类型为 String）。

   • 接着，在 impl 块中，我们为 MyStruct 实现了 Debug trait。在 fmt 方法中，我们使用 write! 宏将格式化后的字符串写入到提供的 Formatter 中。

   • 在这个例子中，我们使用了 {:?} 占位符来表示调试格式。当我们在代码中使用 println!("{:?}", my_struct) 时，Rust 会自动调用 fmt 方法并将 MyStruct 的字段值填充到格式化字符串中，最终打印出类似 "MyStruct { field1: 42, field2: \"Hello\" }" 的调试信息。

3. 在下方这个例子里，并没有对任何类型实现std::fmt::Debug trait

   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);
   }

   原因是T: std::fmt::Debug 只是对T进行注解，泛型T必须是一个实现了std::fmt::Debug trait 的类型，这样在函数中我们就可以放心地使用 {:?} 占位符来打印类型 T 的调试信息，因为编译器已经保证了类型 T 是可以被格式化打印的。