rust入门

Rust 是一种静态类型语言，这意味着在编译时必须知道所有变量的类型。Rust 支持多种数据类型，包括标量类型和复合类型。

标量类型

• 整数类型：有符号和无符号整数，例如 i8、i16、i32、i64 和 u8、u16、u32、u64。
• 浮点类型：f32 和 f64。
• 布尔类型：bool，值为 true 或 false。
• 字符类型：char，用单引号表示，例如 'A'。

复合类型

• 元组：可以包含多个不同类型的值，例如 (i32, f64, char)。
• 数组：固定长度的相同类型值的集合，例如 [i32; 5]。

变量

• 不可变变量：默认情况下，变量是不可变的，一旦赋值后不能更改。
• 可变变量：使用 mut 关键字声明的变量是可变的，可以更改其值。

常量

• 常量：使用 const 关键字声明，必须指定数据类型，且值在编译时确定。

  fn main() {
      // 不可变变量
      let x = 10;
      // 可变变量
      let mut y = 20;
      y = 30; // 正确！y 是可变的
  
      // 常量
      const MAX_NUM: u32 = 100;
  
      // 整数类型
      let integer: i32 = 42;
      let unsigned_integer: u64 = 100;
  
      // 浮点数类型
      let float_num: f64 = 3.14;
  
      // 布尔类型
      let is_rust_cool: bool = true;
  
      // 字符类型
      let my_char: char = 'A';
  
      // 元组
      let tuple: (i32, f64, char) = (1, 2.0, 'c');
  
      // 数组
      let array: [i32; 5] = [1, 2, 3, 4, 5];
  
      // 打印变量和常量的值
      println!("x: {}", x);
      println!("y: {}", y);
      println!("MAX_NUM: {}", MAX_NUM);
      println!("integer: {}", integer);
      println!("unsigned_integer: {}", unsigned_integer);
      println!("float_num: {}", float_num);
      println!("is_rust_cool: {}", is_rust_cool);
      println!("my_char: {}", my_char);
      println!("tuple: {:?}", tuple);
      println!("array: {:?}", array);
  }

  Rust 中有多种函数类型，包括常规函数、闭包、关联函数和方法。Rust 不支持类似 C++ 的虚函数，但可以通过其他方式实现类似的功能

  fn add(a: i32, b: i32) -> i32 {
      a + b
  }
  
  fn main() {
      let result = add(1, 2);
      println!("Result: {}", result); // 输出: Result: 3
  }

  闭包是匿名函数，可以捕获其定义环境中的变量。闭包可以有多种类型，包括 Fn、FnMut 和 FnOnce。

• fn main() {
      let msg = "Hello".to_string();
      let greet = |name: &str| -> String {
          format!("{} {}", msg, name)
      };
  
      let greeting = greet("Rust");
      println!("{}", greeting); // 输出: Hello Rust
  }

关联函数和方法定义在结构体或枚举的 impl 块中。关联函数不以 self 作为第一个参数，而方法则以 self、&self 或 &mut self 作为第一个参数。

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

impl Point {
    // 关联函数
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    // 方法
    fn distance_from_origin(&self) -> f64 {
        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
    }
}

fn main() {
    let p = Point::new(3, 4);
    println!("Distance from origin: {}", p.distance_from_origin()); // 输出: Distance from origin: 5.0
}

Rust 结构体具有以下特性：

1. 字段：结构体可以包含多个字段，每个字段有名称和类型。
2. 方法：结构体可以定义方法，用于操作结构体的字段。
3. 关联函数：结构体可以定义关联函数，用于创建结构体实例或执行与结构体相关的操作。
4. 派生特性：可以使用 #[derive] 属性为结构体派生一些常见的特性，如 Debug、Clone、Copy 等。
5. 生命周期：结构体可以包含生命周期参数，用于确保结构体的引用在有效期内。

#[derive(Debug, Clone, Copy)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // 关联函数
    fn new(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }

    // 方法
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // 方法
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle::new(30, 50);
    let rect2 = Rectangle::new(10, 10);
    let rect3 = Rectangle::new(40, 60);

    println!("rect1 is {:?}", rect1); // 输出: rect1 is Rectangle { width: 30, height: 50 }
    println!("The area of rect1 is {}", rect1.area()); // 输出: The area of rect1 is 1500
    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2)); // 输出: Can rect1 hold rect2? true
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3)); // 输出: Can rect1 hold rect3? false
}