Rust-入门

Hello World!

第一个程序肯定是Hello World啦

fn main(){
	let s = "hello world";
	println!("{}",s);
}

运行结果

hello world

println!使用规范

- ``,which uses the `Display` trait
- `?`,which uses the `Debug` trait
- `e`,which uses the `LowerExp` trait
- `E`,which uses the `UpperExp` trait
- `o`,which uses the `Octal` trait
- `p`,which uses the `Pointer` trait
- `b`,which uses the `Binary` trait
- `x`,which uses the `LowerHex` trait
- `X`,which uses the `UpperHex` trait

测试代码如下

fn main(){
	println!("int {}",1);
	println!("float {}",0.1);
	println!("Debug {:?}","Hello World");
	println!("Pointer {:p}",&0);
	println!("LowerHex {:x}",0x10deadbeef);
	println!("UpperHex" {:X},0x10deadbeef);
	println!("Binary {:b}",0b111);
	println!("{:#?}",("test1","test2"));
	println!("{a} {b} {c}",a="deadbeef",b="cafecafe",c="deadcafe");
}

运行结果

int 1
float 0.1
Debug "Hello World"
Pointer 0x55ced1b49010
LowerHex 10deadbeef
UpperHex 10DEADBEEF
Binary 11
(
	"test1",
	"test2",
)
deadbeef cafecafe deadcafe

变量

---

无mut

fn main(){
	let x = "Hello World";
	println!("{}",x);
}

运行结果

Hello World

注意！无mut，这个变量类似于常量，是不可以更改的。比如如下代码就会报错

fn main(){
	let x = "Hello World";
	x = "deadbeef";
	println!("{}",x);
}

上述代码会弹出cannot assign twice to immutable variable报错，可以通过mut解决

有mut

fn main(){
    let mut name="Hello World";
    println!("{}",name); 
    name = "deadbeef";
    println!("{}",name);
}

运行结果

Hello World
deadbeef

tuple多变量赋值

fn main(){
    let (x,y) = (1,2);
    println!("{x} {y}",x=x,y=y;
}

运行结果

1 2

综合rust的特性作出以下解释

let mut x应该分割成两个部分 let mut x，mut x表示可读写变量x

let x应该分割成两个部分 let x，由于变量x缺省，表示只可读变量x

多变量赋值let (x,y……)应该分割成两个部分 let (x,y……)

变量类型和初始化

定义i32变量举例

fn main(){
	let x:i32 = 0x0FFFFFFF;
	println!("{}",x);
}

运行结果

268435455

定义char变量举例

fn main(){
	let x :u8 = 1;
	println!("{}",x);
	let y :u8 = b'A';
	println!("{}",y);
	let s :&[u8;5] = b"hello";
	println!("{}",s);
	let r :&[u8;14] = br#"hello \n world"#;
	println!("{}",r);
}

运行结果

1
65
[104, 101, 108, 108, 111]
[104, 101, 108, 108, 111, 32, 92, 110, 32, 119, 111, 114, 108, 100]

变量声明时的一些特性

fn main(){
    let var1 = 123usize; //变量类型可以放后面
    let var2 = 0x_FF_u8; //下划线不会对语义造成影响
    let var3 = 32;//默认就是i32
    println!("{:x}",var1);
    println!("{:x}",var2);
    println!("{:x}",var3);

    let var4: i128 = 0xDEAD_BEEF_CAFE_CAFE;//rust整数长度很大，甚至有128位int
    println!("{:X}",var4);

}

可以先声明后初始化

fn test(condition: bool){
	let x: i32; //这里只是声明，并没有做初始化，所以后面可以设置初始值。但是设置之后就不能更改了
	if condition {
		x = 1;
		println!("{}",x);
		// x = 2;如果加了这一行，编译器就会报错
	}
}
fn main(){
	test(true);
}

运行结果

1

rust基础变量类型如下

bool:只有true和false，可以参与&&、||、|、&、^运算
char:为了兼容所有的unicode编码，rust的char是四字节的。如果要单字节的char需要使用u8

变量遮蔽

简单来说就是同名变量覆盖，例子如下

fn main(){
	let x: i32;
	x = 0x100;
	println!("{}",x);
	let mut x:i64;
	x = 0x200;
	println!("{}",x);
	x = 0x300;
	println!("{}",x);
}

运行结果

256
512
768

从上述代码中，被遮蔽的变量已经无法使用了

那么变量遮蔽有什么用呢？有一个比较好的用处就是将变量从只可读和可读可写之间的状态进行转换，例子如下

fn main(){
	let elem = 0x5;
	let mut vec1 = Vec::new();
	vec1.push(elem);
	vec1.push(elem);
	println!("{:?}",vec1);
	let vec1 = vec1;
	// vec1.push(elem); 如果执行这一行就会报错
	println!("{:?}",vec1);
	
	
	let vec2= Vec::new();
	println!("{:?}",vec2);
	let mut vec2 = vec2;
	vec2.push(elem); 如果执行这一行就会报错
	println!("{:?}",vec2);
}

运行结果

[5,5]
[5,5]

[]
[5]

变量推导

声明变量并初始化的时候，如果直接初始化为一个复杂的结构，rust会自动对其进行推导，无需具体定义它的类型

案例1

fn main(){
	let x = [[1,2],[3,4],[5,6]];
	println!("{:?}",x);
}

运行结果

[[1,2],[3,4],[5,6]]

案例2

fn main(){
    let x = [[1,2],[3,4],[5,6]];
    println!("{:?}",x);

    let y = [("Jack",0x10),("Mike",0x20),("Jill",0x30)];
    let players : Vec<_> = y
        .iter()
        .map(|(&(player_name,score))|{
            player_name
        })
        .collect();
    println!("{:?}",players);
}

运行结果

["Jack", "Mike", "Jill"]

上述代码中，并没有声明Vec中的类型，通过rust变量推导，方便的对变量进行初始化

变量类型别名

类似于C语言中的typedef

type Age = u32;
fn grow(age: Age,year: u32) -> Age{
    age + year
}
fn main(){
    let age = 0x10;
    println!("{}",grow(age,0x10));
}

运行结果

32

tuple

---

fn main(){
    let a = (1_i32,(true,false));
    println!("{:?}",a);
    let b = (1_i32,2_i32);
    let (x,y) = b;
    println!("{x} {y}",x = x,y = y);
}

运行结果

(1,(true,false))
1 2

上述案例汇总let (x,y) = b直接将数据从b中取出，这是一个非常方便的方法

Rust IO篇

读取文件并输出

use std::fs::File;
use std::error::Error;
use std::io::Read;
fn main(){
    let mut file = match File::open("/flag") {
        Err(why) => panic!("couldn't open:{}",why.description()),
        Ok(file) => file,
    };
    let mut s = String::new();
    file.read_to_string(&mut s)
        .expect("Can't read flag file!");
    println!("{}",s);
}