起步入门

Format 格式

fn main(){
	let target;
	println!("{}",target);
	println!("{:o}",target);
	println!("{:x}",target);
	println!("{:X}",target);
	println!("{:p}",target);
	println!("{:b}",target);
	println!("{:e}",target);
	println!("{:E}",target);

	println!("{:?}",target);
	println!("{:#?}",target);
	println!("{a}",a=target);
}

变量声明

Rust 变量必须先声明后使用，对于局部变量，最常见的声明语法为：

let variable: i32 = 100;

Rust 中声明变量缺省是 只读 的，比如：

fn main(){
	let x = 5;
	x=10;
}

会报错

如果希望变量是可修改的，那么需要使用 mut 关键字：

fn main(){
	let mut x = 4;
	x = 1;
}

可修改

mut x 是一种 mode 可以描述多个变量。

fn main(){
	let { mut a,mut b} = {1,2};
	let Point { x :ref a,y :ref b} = p;
}

每一个变量必须被初始化，才可以使用。

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

[!TIP]
上述代码实际上会报错

初始化的时候可以不需要，mut 修饰，因为是初始化。

fn main(){
	let x:i32;
	if condition {
		x = 12;
		println!("{}",x);
	}
	// 这里就不能使用 x 了。
	// 两个原因，
	// - 二次赋值不被允许
	// - 没被初始化
}

变量遮蔽

rust 允许在用一个代码块中同时声明同样名字的变量。如果这样做，后声明的变量会将前面声明的变量遮蔽（Shadowing）起来。

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

	let x=1;
	println!("x is {}",x);
}

可以转换变量是否可改；

fn main(){
	let mut v = vec![];
	v.push(1);

	let v = v;

	for i in &v {
		print!("{}",i);
	}
}

反过来也可以。

类型推导

和 TS 类似。RUST 的类型推导功能是很强大的。可以通过上下文信息进行推导。

fn main(){
	let elem = 5u8;
	let mut v= vec![];
	v.push(elem);
	// 到后面调用了 push
	// 根据 elem 确定 v 的类型
}

还可以只写一部分，用 _ 来代替。

类型别名

type 关键字

整数类型

整数类型	有符号	无符号
8 bits	i8	u8
16 bits	i16	u16
32 bits	i32	u32
64 bits	i64	u64
128 bits	i128	u128

范围问题和计算机组成原理一致。
浮点类型也是如此。

指针类型

Rust 中有指针类型，而且不止一种。

类型名	简介
BOX<T>	指向类型 T 的具有所有权的指针、有权释放内存
&T	指向类型 T 的借用指针，也称为引用，无权释放内存，无权写数据
&mut T	指向类型 T 的 mut 型借用指针，无权释放内存，有权写数据
*const T	指向类型 T 的只读裸指针，没有生命周期信息，无权写数据
*mut T	指向类型 T 的可读写裸指针，没有生命周期信息，有权写数据

除了上述指针，还有一种智能指针。

类型名	简介
Rc<T>	指向类型 T 的引用计数指针，共享所有权，线程不安全
Arc<T>	指向类型 T 的原子性引用技术指针，共享所有权，线程安全
Cow<'a,T>	Clone-on-write ，写时复制指针，可能是借用指针，也可能是具有所有权的指针

智能指针和普通指针的区别在于智能指针实际上是对普通指针加了一层封装机制，这样的一层封装机制的目的是为了使得智能指针可以方便的管理一个对象的生命期。

就是为了避免具有引用的对象，莫名其妙被销毁，常用于线程之间共享变量。
智能在自动计数引用，普通的离开了就销毁了。

复合类型

tuple

递归

谈到递归调用，许多读者都会自然联想到"尾递归优化"这个概念。

可惜的是，当前版本的 Rust 暂时还不支持尾递归优化，因此如果递归调
用层次太多的话，是有可能撑爆栈空间的。不过这个问题已经在设计讨
论之中。