前言

以前谁是魔我杀谁，现在我杀谁谁就是魔。——《拔魔》

---

\;\\\;\\\;

Rust基本知识

结构体

#[derive(Debug)]
struct Window_table{width : i32,height : i32,position : (i32,i32),id : i32,name :String,
}fn main(){let W=1920;let H=1080;let a = Window_table{width : 960,height : 600,position : (W/2-480,H/2-300),id : 0x0000_0000_0000_00ff,  //255name : String::from("new win")};println!("{:#?}",a);
}

元组+结构体

struct Color(u8,u8,u8); //3个字节
struct Point(f64,f64);  //16个字节fn main(){let a=Color(166,70,70);println!("a=({},{},{})",a.0,a.1,a.2);let a=Point(400.0,300.0);println!("a=({},{})",a.0,a.1);
}

局部作用域

目前这个例子还是和其他的语言一样，没什么特殊的。

fn main() {let a = 1;{let b = 2;println!("b={}", b);let a = 5_f32;println!("a={}", a);}println!("a={}", a);let a = 'a'; //shadowingprintln!("a={}", a);
}

冻结

fn main() {let mut a = 7i32;{let a = a;//a = 50; //报错，因为外部可变的a被内部不可变的a冻结了！}a = 3;
}

字面量

对于没有表明类型的整数，编译器默认是i32；对于没有表明类型的浮点数，编译器默认是f64

fn main() {let x = 117u8;let y = 20u32;let z = 3.1f32;let i = 5;let f = 3.1415;println!("size of `x` in bytes: {}", std::mem::size_of_val(&x));println!("size of `y` in bytes: {}", std::mem::size_of_val(&y));println!("size of `z` in bytes: {}", std::mem::size_of_val(&z));println!("size of `i` in bytes: {}", std::mem::size_of_val(&i));println!("size of `f` in bytes: {}", std::mem::size_of_val(&f));
}

Vec元素的类型由第一个push进的类型确定

fn main() {let a = 5u8;let b=String::from("Hello");let c:u8 = 1;let mut v = Vec::new();v.push(a);//v.push(b); //错误，因为类型被确定成u8了v.push(c);println!("{:?}", v);
}

type别名

//别名用type
type T1 = u64;
type T2 = u64;
type u8_ = u64;fn main() {let a: T1 = 5 as u8_;let b: T2 = 2 as u8_;println!("{} a + {} b = {} unit?", a, b, a + b);
}

from和into

from函数就是把传入类型转换成自定义的类型，通过是把传入数据赋值给自定义类型的属性

use std::convert::From;#[derive(Debug)]
struct Number {value: i32,
}impl From<i32> for Number {fn from(item: i32) -> Self {Number { value: item }}
}fn main() {let num = Number::from(30);println!("num={:?}", num);let a = 5;let b: Number = a.into();println!("b={:?}", b);
}

TryFrom和TryInto

和from、into一样，但是带错误处理

use std::convert::TryFrom;
use std::convert::TryInto;#[derive(Debug, PartialEq)]
struct EvenNumber(i32);impl TryFrom<i32> for EvenNumber {type Error = ();fn try_from(value: i32) -> Result<Self, Self::Error> {if value % 2 == 0 {Ok(EvenNumber(value))  //传入偶数就返回自定义类型} else {Err(())  //传入奇数就报错}}
}fn main() {assert_eq!(EvenNumber::try_from(8), Ok(EvenNumber(8))); //ok=okassert_eq!(EvenNumber::try_from(5), Err(()));           //err=errlet a: Result<EvenNumber, ()> = 8i32.try_into();  //和a.into()的用法一样assert_eq!(a, Err(()));            //ok!=errlet a: Result<EvenNumber, ()> = 5i32.try_into();assert_eq!(a, Err(()));            //err=err
}

\;\\\;\\\;

表达式

fn main() {let x = 5u32;let y = {let a = x * x;let b = a * x;//返回值不需要分号，意味着最后一句的结果默认是外面接收的b + a + x};let z = {   2 * x;};println!("x is {:?}", x);println!("y is {:?}", y);println!("z is {:?}", z);
}

表达式最后一句加了分号就表示没有返回值