Rust编程（二）语法和数据类型

编程规范

类C语法，函数需要定义，指令需要以；结尾。需要大括号{}
文件名，变量，函数命名使用snake case，eg：new_function()
结构体，特征命名，使用大驼峰命名，eg：Student，ChangeInfo

数据类型

Rust 是 静态类型（statically typed）语言，每个数据都必须声明类型，数据的初始化方式为let a : Type = value;

let a : i32 = 6;
let b : f32 = 6.0;
let c : char = '6';
let d : [i32;6] = [1,2,3,4,5,6]
let e : (char,i32) = ('6',6);
let f : Vec<i32> = Vec::new();
1
2
3
4
5
6

Rust中的变量默认是不可变的，如果想要可变，需要添加mut关键字：

let mut g: i32 = 1;
1

基本标量：

• 整型：i32
• 浮点型：f32
• 布尔类型：bool
• 字符类型：char
  复合数据类型：
• 原生数组：[i32;5]
• 元组:(i32,i32,i8)
• 【Rust 标准库提供】可变数组：Vec
• Sring，字符串
• &str：字符串面值，可以理解为，“abc”就是字符串面值，跟其他语言一样不可更改，而String则是另一种字符串，他可以修改，可以添加，删除，替换等等，跟C++的String别无二样。

所有权

Rust通过控制所有权来实现内存管理
Rust中所有的变量都是有所有权的，变量的初始化被称为变量绑定，即将这个数据绑定到这个变量上。
Rust对于简单基本数据类型，会直接进行拷贝，不会考虑所有权问题，但是对于复杂数据类型，就有所有权制度了，如下

let s1 = Stinrg::from("name");
let s2 : String;
s2 = s1;
println!("{}",s1);
//这种情况就会报错，因为Rust中，对于复杂数据类型，等于号默认就是所有权的交接，
//此时数据的所有权已经从s1转移到s2了，这种称为move
//也就是说，Rust中默认的=是move而不是浅拷贝
//Rust中有一个特征是Copy，实现了Copy特征的，都是拷贝而不是move，
//官方给出的可以Copy的类型规则：任何基本类型的组合可以 Copy ，不需要分配内存或某种形式资源的类型是可以 Copy 的。
1
2
3
4
5
6
7
8
9

Rust中的函数传参也适用所有权制度：

let s3 = String::from("value");
a_function(s3) 
//此时s3数据的所有权已经move给函数了，
//在函数调用结束时，如果所有权不传出来，那么Rust就会自动调用drop清理掉相应数据的内存。

1
2
3
4
5

所有权传来传去很麻烦，所以就设计了引用和借用机制：

let x: i32 = 1;
let y = &x;

println!("{},{}",x,*y);
//引用机制，直接指向同一个地址
1
2
3
4
5

引用，一个指针指向了原数据类型，只能看不能改。

还记得前面说的可变与不可变性吗？如果想要获得修改权，就需要借用，引用只能看不能改。

let x: i32 = 1;
let temp = &x; //引用，一旦引用了，原数据就不能再被借用了，确保在引用期间数据不会改变。
let y = &mut x; //借用，把上面的那句引用注释掉就可以借用了
*y = 6; //借用，可以修改
println!("The value of y is: {}", y);
println!("The value of x is: {}", x); //会报错，此时x处于被借用状态，自己没法用
let y = 1; //给y绑定一个新的值，把原本的y覆盖掉
println!("The value of x is: {}", x); //此时就又可以用了，而且值也已经修改了。
//其实不覆盖也可以，因为Rust检测到后面y不用了就会自动把借用还回去，可以把let y = 1注释掉，依旧可以。
1
2
3
4
5
6
7
8
9

其实所有权，引用和借用的机制很简单，就是把数据和变量分开了，变量是数据的所有者，所有权就是指把数据分配给这个变量了。
转移所有权就是指把这个数据转移给另一个变量，原变量就go die了。
引用就是指可以看这份数据但是不能改，而且数据的所有者不能再把数据借给其他变量。
借用就是指将数据暂时借给其他变量，在借给其他变量后，原变量就像个植物人一样，啥也不能干，但是借用一旦归还，就又活过来了。

控制流

常见if-else，for，while，该有的都有

函数

fn function(inputvalue:input_type,inputvalue2:input_type2) -> return_type {
	println!("This is a function");
	let result: return_type = value;
	return result;
}
1
2
3
4
5

结构体

Rust中没有类的概念，取而代之的是跟C一样的struct，struct不能继承，早期的Rust有virtual struct，是可以继承的，后面删除了，不能使用继承了。Rust实现多态的方式是使用特征trait。

封装继承，多态，是面向对象编程的三个特征，这是目前最常见的说法。不过我们跳出这三个特征来谈OOP(面向对象)，我们会发现，其实面向对象的主要思想就类似于状态机一样，对象就是状态的封装，通过行为来不断改变状态，最终得到结果，而多态是为了实现同一个行为可以应对复用在多个状态机上。从这个角度出发，我们就不难理解为什么Rust要这么设计了，Rust认为要实现多态不一定非要使用继承，继承反而会破坏掉封装，我们的目的只是要复用行为，没必要把状态机之间扯上关系，所以，Rust将状态和行为分开封装，状态封装为了struct，行为封装成了方法，而想要在多个状态上复用的行为，封装成了特征，struct不需要知道自己和哪个struct共用特征，只需要实现相应的特征即可，特征在特定的上下文也可以识别出自己接受的struct类型，达到和继承一样的效果。不过Rust官方并不称为自己是面向对象语言，虽然可以用OOP的方法来编程，但是会跟所有权等机制格格不入。

struct Person{
	name : String,
	age : i32,
	address : String,
}
1
2
3
4
5

方法

跟传统OOP中的成员函数一样。

impl Person{
	fn change_name(&mut self,new_name) -> (){
		self.name = new_name;
	}
}
1
2
3
4
5

特征trait

trait是Rust中独有的一种机制，有点像接口类的概念，如果不同的类型具有相同的行为，那么我们就可以定义一个特征，然后为这些类型实现该特征。定义特征是把一些方法组合在一起，目的是定义一个实现某些目标所必需的行为的集合。
如下，我们定义了一个特征，名称为ChangeInfo，所有有该行为需求的类都可以实现一个该特征，例如Student和Teacher。

pub trait ChangeInfo{
    fn change_name(&mut self,new_name) -> (); //注意，这里是；不是{}
    fn init_all_info(&mut self) -> (){ //也可以设置默认实现，默认实现允许调用相同特征中的其他方法，哪怕这些方法没有默认实现。
    	self.change_name(String::new());
	}
}

struct Student{
	name: String,
}

impl ChangeInfo for Student{
	fn change_name(&mut self,new_name) -> (){
		self.naem = new_name;
	}
}

struct Teacher{
	name: String,
}

impl ChangeInfo for Teacher{
	fn change_name(&mut self,new_name) -> (){
		self.naem = new_name;
	}
}

fn main(){
	let student:Student = Student{
		name:String::new(),
	}
	student.init_all_info();
	student.change_name(String::from("Wang"));
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

还可以使用特征来作为参数：

pub fn function(item: &impl ChangeInfo) { //使用实现了ChangeInfo的类型作为参数
    item.init_all_info();
}
1
2
3

trait还有很多应用方法，具体可以看Rust圣经

泛型

Rust支持泛型编程，跟C++的泛型没有很大区别
Rust中的泛型也分为：函数泛型，结构体泛型
Rust中的泛型也可以进行模板特化，为某一种特殊的数据类型进行单独实现。
Rust在1.5以后也可以支持类似于C++参数模板的功能了。

fn display_array<T: std::fmt::Debug, const N: usize>(arr: [T; N]) {
//T是要实现了Debug特征的类型，N是一个const 泛型，是一个值
    println!("{:?}", arr);
}
fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    display_array(arr);

    let arr: [i32; 2] = [1, 2];
    display_array(arr);
}
1
2
3
4
5
6
7
8
9
10
11

总结

Rust面向对象上与C++有理念上的不同，所以实现也有较大区别，但是在泛型上，跟C++区别不大。至于Rust所独有的所有权以及借用和引用，是为了实现内存安全和像C++一样的速度而设计的，如果依旧使用深拷贝和浅拷贝机制，不加以管理让用户自己选择拷贝策略或者像Python一样默认浅拷贝，会内存不安全。如果默认深拷贝，则会效率极低。

Python可以默认浅拷贝是因为有GC兜底，内存管理不依赖程序员。

所以，Rust比较新，但是也没有说新到颠覆一切。合理看待。