rust学习 (3)

fn main(){
    struct Foo(i32);
    impl Foo {
        fn new() -> Self {
            Self(0)
        }
    }
    assert_eq!(Foo::new().0, Foo(0).0);
}

上面示例中Self（注意S和s）等同于Foo，表示的是new方法的返回值为Foo结构体类型。
assert!(x),若x为true则正常往下执行，若x为false，则panic。assert_eq!(x,y),若x==y则正常往下执行，若x!=y则panic。
ps：struct方法声明里的self或者&mut self是一个语法糖，相当于self: Self或者 self: &mut Self。

if let Some(x) = option {
	foo(x);
}

如果一个模式匹配成功，它将给模式的标识符绑定任意合适的值，然后执行{}内的语句。如果模式不匹配，则什么也不去做。
当模式不匹配时，如果你希望去做别的事情,您可以使用 else：

fn main() {
   let s= String::from("你好");
   let h = &s[0..3];
   println!("h = {}",h);
}

取字符串"你"，取的时候要写边界，"你"占第0字节到第2字节。

fn main() {
   let s= String::from("hello world");
   let h = &s[0..3];//字符串slice是String中一部分值的引用,h是字符串类型的slice,h指向s中"hello"。
   let s1 ="hhh"//s1是字符串字面值类型，也是字符串slice类型，记为为&str，是一个不可变引用，存储在内存的代码段。
   println!("h = {}",h);
}

字符串slice变量h（存储在栈上）内部构造为一个ptr指向’h’，一个len为5，还有一个capacity。

fn main() {
    #[derive(Debug)]
    struct User {
      name: String,
      account: String,
      nonce: u64,
      active: bool,
    }

    let user1 =User {
      name: String::from("xiaoming"),
      account: String::from("2143314"),
      nonce: 10000,
      active: true,
    };
    println!("user1 = {:#?}", user1);//打印一个字段换一行加'#'，否则不加
}

使用#[derive(Debug)]打印结构体变量

枚举类型的经典用法

enum Message{//Quit,Move,Write,Change都是成员名字。其中Quit是没有值的，是单元值类型
    Quit,
    Move{x: i32, y: i32},
    Write(String),
    Change(i32,i32,i32),
}
//定义Message这个枚举类型等同于定义以下4个结构体
struct QuitMessage//类单元结构体
struct MoveMessage{
    x: i32,
    y: i32,
}
struct WriteMessage(String)//元组结构体
struct ChangeMessage(i32, i32, i32)//元组结构体

可变引用是借用
异步编程：主线程和工作线程并行运行
字符串里一个中文字符占3字节，一个英文字符占1字节，使用String::len。

#[derive(Debug)]
struct Student {
    name: String,
    id: String,
    score: i32,
}
#[derive(Debug)]
enum Teacher {
    //理解成teacher枚举类型有两个子类型，一个是nan类型存放了String，一个是nv类型也存放了String，可以利用match语句提值
    nan(String),
    nv(String),
}
fn main() {
    let stu1 = Student {
        name: String::from("jack"),
        id: String::from("201413"),
        score: 100,
    };
    println!("stu1 ={:#?}", stu1);
    let tc1 = Teacher::nan(String::from("math"));
    println!("tc1 = {:#?}", tc1);
    match tc1 {
        Teacher::nan(s) => {println!("男老师科目是{}",s);}
        Teacher::nv(s) => {println!("女老师科目是{}",s);}
    }
    //println!("tc1 = {:#?}", tc1);  匹配之后，tc1里的子类型的String值发生了所有权转移，String值也是tc1的一部分，所以这个tc1的所有权转移了，无法再使用
    // println!("科目是{}",s); s的作用域是match的语句块，出了就被自动drop掉了（String有drop trait）
     
}
//let a = b;若b变量有Copy trait 那么在内存中就是深拷贝，不会发生所有权的转移。如果没有的话就类似与String变量赋值那样，会发生所有权转移。

定义结构体类型，枚举类型时，写在main里还是外都不用加’;’,cargo fmt命令可调整格式。

猜你喜欢