RUST B站代码（不全面）

Rust编程视频教程（基础）

视频中所有例子源码地址 重点
https://github.com/anonymousGiga/learn_rust

二 RUST环境安装
curl -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
rustc --version

新建工程
[root@kolla ~]# mkdir -p ~/source/rust/learn_rust
[root@kolla ~]# cd source/rust/learn_rust/
[root@kolla learn_rust]# cargo new hello  #创建
[root@kolla hello]# pwd
/root/source/rust/learn_rust/hello
[root@kolla hello]# cargo run   #运行
[root@kolla hello]# cargo build #编译
[root@kolla hello]# cargo check #检查语法

三变量
[root@kolla learn_rust]# cargo new learn_var
[root@kolla learn_rust]# cd learn_var/
[root@kolla learn_var]# cat src/main.rs
const MAX_POINTS: u32 = 100000;
fn main() {
    //变量定义
    let a = 1 ;                    //变量 a 不能再次赋值是不可变的
    let mut b: u32 = 1;            //变量 b 可以再次赋值是可变的
    println!("a = {}", a);
    println!("b = {}", b);

    b=2;                           //再次赋值
    println!("b = {}", b);

    //隐藏
    let b: f32 = 1.1;
    println!("b = {}", b);

    //常量
    println!("MAX_POINTS = {}", MAX_POINTS);
    println!("Hello, world!");
}
[root@kolla learn_var]# cargo run
a = 1
b = 1
b = 2
b = 1.1
MAX_POINTS = 100000
Hello, world!
[root@kolla learn_var]#


四 类型
[root@kolla learn_rust]# cargo new learn_type
[root@kolla learn_type]# cat src/main.rs
fn main() {
    //bool
    let is_true: bool = true;
    println!("is_true = {}", is_true);

    let is_false = false;
    println!("is_false = {}, {}", is_false, is_true);

    //char 在rust里面，char是32位的
    let a = 'a';
    println!("a = {}", a);

    let b = '你';
    println!("b = {}", b);

    //i8, i16, i32, i64, u8, u16, u32, u64, f32, f64
    let c: i8 = -111;
    println!("c = {}", c);

    let d: f32 = 0.0009;
    println!("d = {}", d);

    //自适应类型isize, usize
    println!("max = {}", usize::max_value());

    //数组
    //[Type; size] , size 也是数组类型的一部分
    let arr: [u32; 5] = [1, 2, 3, 4, 5];
    let arr1: [u32; 3] = [1, 2, 3];
    println!("arr[0] = {}", arr[0]);

    show(arr1);

    //元组
    let tup: (i32, f32, char) = (-3, 3.69, '好');
    let tup = (-3, 3.69, '好');
    println!("--------------------");
    println!("{}", tup.0);
    println!("{}", tup.1);
    println!("{}", tup.2);
    println!("--------------------");

    let (x, y, z) = tup;
    println!("{}", x);
    println!("{}", y);
    println!("{}", z);

    println!("Hello, world!");
}

fn show(arr:[u32;3]) {
    println!("--------------------");
    for i in &arr {
        println!("{}", i);
    }
    println!("--------------------");
}
[root@kolla learn_type]#


五函数
[root@kolla learn_fn]# cat src/main.rs
fn other_fun() {
    println!("This is a function");
}

fn other_fun1(a: i32, b: u32) {
//fn other_fun1(a, b) { //error
    println!("a = {}, b = {}", a, b);
}

fn other_fun2(a: i32, b: i32) -> i32 {
    let result = a + b;
    return result;
}

fn other_fun3(a: i32, b: i32) -> i32 {
    //let result = a + b;
    //result
    a + b
}

fn main() {
    other_fun();

    let a: i32 = -1;
    let b: u32 = 2;
    other_fun1(a, b);

    let c: i32 = 9;
    let r: i32 = other_fun2(a, c);
    println!("r = {}", r);

    let r2: i32 = other_fun3(a, c);
    println!("r2 = {}", r2);

    //语句是执行一些操作，但是不返回值的指令
    //let y = 1; //语句，不返回值
    //let x = (let y = 1);

    //表达式会计算一些值
    let y = {
        let x = 1;
        //x + 1;
        x + 1
    };

    println!("y = {}", y);

    println!("Hello, world!");
}
[root@kolla learn_fn]#


六注释
//

七 控制流
[root@kolla learn_rust]# cargo new learn_con
fn main() {
    //if
    let y = 0;
    if y == 1 {
        println!("y = 1");
    }

    //if-else
    if y == 1 {
        println!("y = 1");
    } else {
        println!("y != 1");
    }

    //if - else if - else
    println!("++++++++++++");
    let y = 2;
    if y == 1 {
        println!("y = 1");
    } else if y == 0 {
        println!("y = 0");
    } else if y == 2 {
        println!("y = 2");
    } else {
        println!("other");
    }

    //let中使用if
    let condition = true;
    let x = if condition {
        5
    } else {
        6
        //"six" //error
    };

    println!("x = {}", x);

    //loop
    let mut counter = 0;
    loop {
        println!("in loop");
        if counter == 10 {
            break;
        }

        //counter = counter + 1;
        counter += 1;
    }

    let result = loop {
        counter += 1;
        if counter == 20 {
            break counter*2;
        }
    };
    println!("result = {}", result);

    //while
    let mut i = 0;
    while i != 10 {
        i += 1;
    }
    println!("i = {}", i);

    //for
    println!("+++++++++++++++");
    let arr:[u32; 5] = [1, 2, 3, 4, 5];
    //for element in arr.iter() {
    for element in &arr {
        println!("element = {}", element);
    }
    println!("Hello, world!");
}


八 所有权
[root@kolla learn_rust]# cargo new learn_own

//1 rust通过所有权机制来管理内存，编译器在编译就会根据所有权规则对内存的使用进行检查
//
//2 堆和栈
//编译的时候数据的类型大小是固定的，就是分配在栈上的
//编译的时候数据类型大小不固定，就是分配堆上的
//
//3 作用域:{}
//
//4 String内存回收
//5 移动
//6 clone
//7 栈上数据拷贝
//8 函数和作用域
fn main() {
    let x: i32 = 1;

    {
        let y: i32 = 1;
        println!("x = {}", x);
        println!("y = {}", y);
    }

    {
        let s1 = String::from("hello");
        //s1.push_str(" world");
        println!("s1 = {}", s1); //String类型离开作用域的时候会调用drop方法

        let s2 = s1;
        println!("s2= {}", s2);
        //println!("s1= {}", s1); //move to s2, s1 invalid
        //

        //clone
        let s3 = s2.clone();
        println!("s3= {}", s3);
        println!("s2= {}", s2);
    }

    //copy trait
    let a = 1;
    let b = a;
    println!("a = {}, b = {}", a, b);
    //常用的具有copy trait有：
    //所有的整型
    //浮点型
    //布尔值
    //字符类型 char
    //元组




[root@kolla learn_rust]#cargo new learn_fn2
[root@kolla learn_rust]# cat learn_fn2/src/main.rs
fn takes_ownership(some_string: String){
    println!("{}",some_string);
}
fn makes_copy(i: i32) {
    println!("i = {}", i);
}

fn main() {
    let s = String::from("hello");
    takes_ownership(s);
    let x = 5;
    makes_copy(x);
}
[root@kolla learn_rust]#

九 引用
[root@kolla learn_rust]# cargo new learn_ref
[root@kolla src]# cat main.rs
//fn main() {
//    let s1 = gives_ownership();
//    println!("s1 = {}", s1);
//
//    let mut s2 = String::from("hello");
//    let s3 = takes_and_gives_back(s2);
//    s2 = takes_and_gives_back(s3);
//    println!("s2 = {}", s2);
//
//    println!("Hello, world!");
//}
//
//fn gives_ownership() -> String {
//    let s = String::from("hello");
//    s
//}
//
//fn takes_and_gives_back(s: String) -> String {
//    s
//}
//引用: 用法&,
//让我们创建一个指向值的应用，但是并不拥有它，因为不拥有这个值，所以，当引用离开其值指向的作用域后也不会被丢弃
//借用:&mut
fn calcute_length(s: &String) ->usize {
    s.len()
}

fn modify_s(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    let mut s1 = String::from("hello");

    //let s = &s1;
    //let len = calcute_length(s);
    //println!("len = {}", len);

    //let ms = &mut s1;
    //modify_s(ms);

    //println!("s1 = {}", s1);
    //println!("s = {}", s);
    //println!("ms = {}", ms);

    let r1 = &s1;
    let r2 = &s1;
    println!("{}, {}", r1, r2);

    let r3 = &mut s1;
    r3.push_str(", world");
}
[root@kolla src]#
[root@kolla learn_rust]# cargo new learn_ref2
[root@kolla learn_ref2]# cat src/main.rs
//1、在任意给定时间，有了可变引用之后不能再有不可变引用
//2、引用必须有效
fn main() {
    let ref_s = dangle();
    println!("Hello, world!");
}

fn dangle() -> &String {
    let s = String::from("hello");
    &s
}
[root@kolla learn_ref2]#


十 slice
[root@kolla learn_rust]# cargo new learn_slice
[root@kolla learn_slice]# cat src/main.rs

fn main() {
        let s = String::from("hello world");
        let h = &s[0..5];
        let h = &s[0..=4];
        let h = &s[..=4]
        println!("h = {}", h);
        
        println!("Hello, world!");
}
[root@kolla learn_slice]#


十一结构体
[root@kolla learn_rust]# cargo new learn_stru
[root@kolla learn_rust]# cd learn_stru/
[root@kolla learn_stru]# cat src/main.rs

fn main() {
    //1、定义结构体
    #[derive(Debug)]
    struct User {
        name: String,
        count:String,
        nonce: u64,
        active: bool,
    }

    //2、创建结构体实例
    let xiaoming = User {
        name: String::from("xiaoming"),
        count: String::from("80001000"),
        nonce: 10000,
        active:true,
    };
    println!("xiaoming = {:?}", xiaoming);
    println!("xiaoming = {:#?}", xiaoming);

    //3、修改结构体字段
    let mut xiaohuang = User {
        name: String::from("xiaohuang"),
        count: String::from("80001000"),
        nonce: 10000,
        active:true,
    };

    xiaohuang.nonce = 20000;

    //4、参数名字和字段名字同名的简写方法
    let name = String::from("xiaoxiao");
    let count = String::from("89077777");
    let nonce = 200000;
    let active = false;

    //let user1 = User {
    //    name: name,
    //    count: count,
    //    nonce: nonce,
    //    active: active,
    //};

    let user1 = User {
        name,
        count,
        nonce,
        active,
    };

    //5、从其它结构体创建实例
    let user2 = User {
        name: String::from("user2"),
        ..user1
    };
    println!("name = {}", user2.name);
    println!("nonce = {}", user2.nonce);

    //6、元组结构体
    //(1)字段没有名字
    //（2）圆括号
    struct Point(i32, i32);

    let a = Point(10, 20);
    let b = Point(30, 11);

    println!("a.x = {}, a.y = {}", a.0, a.1);

    //7、没有任何字段的类单元结构体
    struct A{};

    //8、打印结构体
    println!("Hello, world!");
}

[root@kolla learn_stru]#


十二 方法

[root@kolla rust]# cargo new learn_stu2
#[derive(Debug)]
struct Dog {
    name: String,
    weight: f32,
    height: f32,
}

impl Dog {
    fn get_name(&self) -> &str {
        &(self.name[..])
    }

    fn get_weight(&self) -> f32 {
        self.weight
    }

    //fn get_height(&self) -> f32 {
    //    self.height
    //}

    fn show() {
        println!("oh oh oh");
    }
}

impl Dog{
    fn get_height(&self) -> f32 {
        self.height
    }
}

fn main() {
    let dog = Dog {
        name: String::from("wangcai"),
        weight: 100.0,
        height: 70.5,
    };

    println!("dog = {:#?}", dog);
    println!("name = {}", dog.get_name());
    println!("weight = {}", dog.get_weight());
    println!("height = {}", dog.get_height());

    Dog::show();

    println!("Hello, world!");
}

十三 枚举类型与匹配
[root@kolla rust]# cargo new learn_enum
//1、类似于c语言的方式定义
enum IpAddrKind {
    V4,
    V6,
}

struct IpAddr {
    kind: IpAddrKind,
    address: String,
}

//2、rust语言提倡的方式定义
enum IpAddr2 {
    V4(String),
    V6(String),
}

//3、可以是不同类型
enum IpAddr3 {
    V4(u8, u8, u8, u8),
    V6(String),
}

//4、经典用法
enum Message {
    Quit,
    Move{x: i32, y: i32},
    Write(String),
    Change(i32, i32, i32),
}

//等同于
//struct QuitMessage; //类单元结构体
//struct MoveMessage {
//  x: i32,
//  y: i32,
//}
//struct WriteMessage(String)
//struct Change(i32, i32, i32)

//5、枚举类型的方法以及match
impl Message {
    fn prin(&self) {
        match *self {
            Message::Quit => println!("Quit"),
            Message::Move{x, y} => println!("Move x = {}, y = {}", x, y),
            Message::Change(a, b, c) => println!("Change a = {}, b = {}, c = {}", a, b, c),
            _ => println!("Write")
            //Message::Write(&s) => println!("Write = {}", s)
        }
    }
}

fn main() {
    let i1 = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };

    let i2 = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
    };

    let i1 = IpAddr2::V4(String::from("127.0.0.1"));
    let i2 = IpAddr2::V6(String::from("::1"));

    let i1 = IpAddr3::V4(127, 0, 0, 1);
    let i2 = IpAddr3::V6(String::from("::1"));

    let quit = Message::Quit;
    quit.prin();


    let mo = Message::Move{x: 10, y: 20};
    mo.prin();

    let wri = Message::Write(String::from("Hello"));
    wri.prin();

    let change = Message::Change(1, 2, 3);
    change.prin();
    println!("Hello, world!");
}


十四 option

[root@kolla learn_rust]# cargo new learn_option
     Created binary (application) `learn_option` package
[root@kolla learn_rust]# cd learn_option/src/
[root@kolla src]# cat main.rs
//1、Option是标准库定义的一个枚举，形式：
//enum Option<T> {
//  Some(T),
//  None,
//}
//
//2、使用方式
fn main() {
    let some_number = Some(5);
    let some_string = Some(String::from("a string"));
    let absent_number: Option<i32> = None;

    let x: i32 = 5;
    let y: Option<i32> = Some(5);
    let mut temp = 0;
    match y {
        Some(i) => { temp = i; }
        None => {println!("do nothing");}
    }

    let sum = x + temp;
    println!("sum = {}", sum);

    //let result = plus_one(y);
    //match result {
    //    Some(i) => println!("result = {}", i),
    //    None => println!("nothing"),
    //};

    if let Some(value) = plus_one(y) {
        println!("value = {}", value);
    }


    if let Some(value) = plus_one(y) {
        println!("value = {}", value);
    } else {
        println!("do nothing");
    }

    println!("Hello, world!");
}

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(x) => Some(x+1),
    }
}
[root@kolla src]#


十五 vector
[root@kolla learn_rust]# cargo new learn_vector
[root@kolla learn_vector]# cat src/main.rs
//1、创建空的vector: Vec<T>
//2、创建包含初始值的vector
//3、丢弃vector
//4、读取元素
//5、更新
//6、遍历
//7、使用枚举
fn main() {
    //1
    //let v: Vec<i32> = Vec::new();
    let mut v: Vec<i32> = Vec::new();
    //v.push(1);

    //2
    let v = vec![1, 2, 3];

    //3
    {
        let v1 = vec![1, 2, 3];
    }

    //4
    let one: &i32 = &v[0];
    //let four: &i32 = &v[3];
    println!("one = {}", one);
    println!("one = {}", *one);

    //(2)推荐的方法
    //match v.get(1) {
    match v.get(3) {
        Some(value) => println!("value = {}", value),
        _ => println!("None"),
    }

    //5
    let mut v2: Vec<i32> = Vec::new();
    v2.push(1);
    v2.push(2);
    v2.push(3);

    //6
    //(1)不可变的遍历
    for i in &v2 {
        println!("i = {}", i);
    }

    //(2)可变的遍历
    for i in &mut v2 {
        *i += 1;
        println!("i = {}", i);
    }


    //7
    enum Context {
        Text(String),
        Float(f32),
        Int(i32),
    };

    let c = vec![
        Context::Text(String::from("string")),
        Context::Int(-1),
        Context::Float(0.001)
    ];



    //8、补充
    let mut v = vec![1, 2, 3, 4, 5];
    let first = &v[0];
    v.push(6);
    println!("first = {}", first);

    println!("Hello, world!");
}

来源：CSDN

作者：张金玉

链接：https://blog.csdn.net/xsjzdrxsjzdr/article/details/104283846