编程规范
类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();
Rust中的变量默认是不可变的，如果想要可变，需要添加mut关键字：
let mut g: i32 = 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 的。
Rust中的函数传参也适用所有权制度：
let s3 = String::from("value");
a_function(s3)
//此时s3数据的所有权已经move给函数了，
//在函数调用结束时，如果所有权不传出来，那么Rust就会自动调用drop清理掉相应数据的内存。
所有权传来传去很麻烦，所以就设计了引用和借用机制：
let x: i32 = 1;
let y = &x;
println!("{},{}",x,*y);
//引用机制，直接指向同一个地址
引用，一个指针指向了原数据类型，只能看不能改。
还记得前面说的可变与不可变性吗？如果想要获得修改权，就需要借用，引用只能看不能改。
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注释掉，依旧可以。
其实所有权，引用和借用的机制很简单，就是把数据和变量分开了，变量是数据的所有者，所有权就是指把数据分配给这个变量了。
转移所有权就是指把这个数据转移给另一个变量，原变量就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;
}
结构体
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,
}
方法
跟传统OOP中的成员函数一样。
impl Person{
fn change_name(&mut self,new_name) -> (){
self.name = new_name;
}
}
特征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"));
}
还可以使用特征来作为参数：
pub fn function(item: &impl ChangeInfo) { //使用实现了ChangeInfo的类型作为参数
item.init_all_info();
}
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);
}
总结
Rust面向对象上与C++有理念上的不同，所以实现也有较大区别，但是在泛型上，跟C++区别不大。至于Rust所独有的所有权以及借用和引用，是为了实现内存安全和像C++一样的速度而设计的，如果依旧使用深拷贝和浅拷贝机制，不加以管理让用户自己选择拷贝策略或者像Python一样默认浅拷贝，会内存不安全。如果默认深拷贝，则会效率极低。
Python可以默认浅拷贝是因为有GC兜底，内存管理不依赖程序员。
所以，Rust比较新，但是也没有说新到颠覆一切。合理看待。
