初始 Rust

安装

通过命令行安装 rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

安装完成后，执行命令，查看 rust 版本

cargo --version

创建项目

cargo new hello

编译项目

cargo build

编译后的的文件会保存在 target/debug/hello

执行这个文件就可以看到输出结果了

这种编译方式编译出来的产物更小，性能更好

cargo build --release

这种方式编译后的产物在 target/release/hello

变量

rust 中分为变量和常量

变量又分为不可变变量和可变变量，默认情况下变量是不可变的

变量不可变是 rust 带来的优势，它使得我们可以利用 rust 提供的安全性来简化去编写多线程的代码，因为多线程代码最主要的一个 bug 来源是数据竞争，数据竞争来源于对数据的修改

声明一个可变的变量，需要在变量名前加上 mut 关键字

let mut x = 5;

常量是不可变的，且始终是不可变的，常量使用 const 关键字声明，并且必须指定类型

const MAX_POINTS: i32 = 42;

数据类型

整数类型：

• i8 i16 i32 i64 i128 isize
• u8 u16 u32 u64 u128 usize

浮点类型：

• f32 f64

布尔类型：

• bool

字符类型：

• char
• String

数组类型：

• [T; N]：T 代表数组中元素的类型，N 代表数组的长度

遍历

let arr = [1,2,3,4,5];
for i in arr.iter() {
    println!("{}", i);
}

结构体

如果需要修改结构体字段的值，需要在声明变量时使用 mut 关键字

struct User{
    username: String,
    age: u64,
    email: String,
    active: bool,
}
fn main() {
  let mut someone = User{
    username: String::from("someone"),
    age: 16,
    email: String::from("1500846601@qq.com"),
    active: true,
  };
  println!("username: {}", someone.username);
  someone.age = 18;
  println!("age: {}", someone.age);
}

函数

struct User{
    username: String,
    age: u64,
    email: String,
}
fn main() {
  let mut someone = User{
    username: String::from("someone"),
    age: 16,
    email: String::from("1500846601@qq.com"),
  };
sayhello(&someone);
}

fn sayhello(user: &User){
  println!("Hello, {}, Your email is {}, Your age is {}", user.username, user.email,user.age);
}

方法

struct User{
    username: String,
    age: u64,
    email: String,
}

impl User{
  fn sayhello(&self){
    println!("Hello, {}, Your email is {}, Your age is {}", self.username, self.email,self.age);
  }
}

fn main() {
  let mut someone = User{
    username: String::from("someone"),
    age: 16,
    email: String::from("1500846601@qq.com"),
  };
  someone.sayhello();
}

泛型

fn largest<T: std::cmp::PartialOrd>(a:T,b:T)->T{
  if a > b {
    a
  } else {
    b
  }
}

fn main() {
  println!("{}", largest::<i32>(1, 2));
  println!("{}", largest::<f32>(1.1, 2.2));
}

两个泛型：

enum Option<T> {
  Some(T),
  None,
}

enum Result<T, E> {
  Ok(T),
  Err(E),
}

具体使用：

match std::env::home_dir(){
  Some(path) => {
    println!("Home directory: {:?}", path);
  },
  None => {
    println!("Impossible to get your home directory.");
  }
}

match std::env::var("LANG"){
  Ok(path) => {
    println!("Current directory: {:?}", path);
  },
  Err(e) => {
    println!("Impossible to get the current directory: {}", e);
  }
}

引用

引用的一些规则：

1. 不会获取所有权
2. 默认情况下是不可变的
3. 同一时间最多只能存在一个可变引用

Option

Option 有两个变体：

enum Option<T> {
    Some(T),    // 包含一个值
    None        // 表示没有值
}

基本使用：

let x: Option<i32> = Some(5);   // 有值：5
let y: Option<i32> = None;      // 没有值

处理 Option 的值：

let result = Some(42);
match result {
    Some(value) => println!("值是: {}", value),
    None => println!("没有值")
}

Some 常用于：

1. 表示可能为空的值
2. 函数可能失败的返回值
3. 结构体中的可选字段

在函数中使用 Option：

fn divide(x: f64, y: f64) -> Option<f64> {
    if y == 0.0 {
        None // 除数为 0，返回 None
    } else {
        Some(x / y) // 正常情况，返回 Some(结果)
    }
}

用 Rust 编写一个简单的结构体

use std::cell::RefCell;
use std::rc::Rc;
struct Node<T> {
    value: T,
    left: Option<Rc<RefCell<Node<T>>>>,
    right: Option<Rc<RefCell<Node<T>>>>,
}
fn main() {
    let mut root = Node {
        value: 1,
        left: None,
        right: None,
    };
    let left = Node {
        value: 2,
        left: None,
        right: None,
    };
    let right = Node {
        value: 3,
        left: None,
        right: None,
    };
    root.left = Some(Rc::new(RefCell::new(left)));
    root.right = Some(Rc::new(RefCell::new(right)));
    println!("root = {:?}", root.value);

    if let Some(ref x) = root.left {
        x.borrow_mut().value = 5;
    }
    println!("root.left = {:?}", root.left.unwrap().borrow().value);
}