先序文章请看：
面向C++程序员的Rust教程（一）
所有权与移动语义
要说Rust语言跟其他语言最大的区别，那笔者觉得非数这个所有权和移动语义莫属。
深浅复制
对于绝大多数语言来说，变量/对象之间的赋值通常都是复制语义。例如C++中：
void Demo() {
Obj o1; // 对象1
auto o2 = o1; // 复制语义，o2是o1的复制
}
只不过深复制还是浅复制需要进一步研究。C++中由于完全支持栈上部署自定义类型以及自定义的拷贝构造/赋值函数，程序员需要自行判断内部指针/引用关系，决定使用深复制或是浅复制。
一些语言是把「结构体」和「类」做区分，结构体仅用于做数据聚合，部署在栈上，而类则添加更多OO特性，部署在堆上（然后栈上给一个指针）。比如说Swift和C#就是如此。那么这种情况下栈上部署的类型，复制就为深复制，而堆上部署的类型复制就为浅复制。
还有一些语言索性不允许自定义类型在栈上部署（比如java、OC），那么这种情况下也就是限定了默认的复制均为浅复制，例如下面OC的例子：
void Demo() {
Object *o1 = [[Object alloc] init];
Object *o2 = o1; // 由于栈上只有指针，因此复制一定是浅复制
}
总之，统一的原则都是「栈上做深复制」，所以如果栈上是完整数据那么就是深复制，如果栈上只有指针/引用，那么就是浅复制。
rust移动语义
但Rust非常特殊，他根本不在这里纠结深复制还是浅复制的问题，而Rust默认为「移动语义」而非「复制语义」。当然，这只针对自定义类型来说，对于整数、浮点数这些它仍然是简单的值复制。我们来看一个例子：
fn main() {
let mut a = 5;
let b = a;
a = 10;
println!("{},{}", a, b); // 10,5
}
这种基本类型看上去无可厚非，但如果换成自定义类型结果可能大大超出预期：
struct Test {
a: i32,
b: i32
}
fn main() {
let mut t = Test{a: 1, b: 2};
let t2 = t;
t.a = 8; // ERROR
}
我们会发现，在尝试更改t.a的时候，编译报错了，报错信息如下：
意思就是说，我们尝试去操作了一个已经被移动的变量t。换句话说，let t2 = t;这一行语句，隐含了「移动语义」。
由于Test是自定义类型，因此它会被部署在堆上，main函数栈中的t则是它的一个指针。之后我们把t赋值给t2的时候，相当于把「对象的所有权」「转移」给了t2，也就是说，赋值之后，t2成为了指向原始对象的指针，同时，t不可以再被使用。
如果和C++做对比，大致上可以等价于下面的代码：
struct Test {
int32_t a;
int32_t b;
};
int main() {
Test *t = new Test(1, 2); // 自定义类型部署在堆上
auto t2 = t; // 所有权转交
t = nullptr; // 原始指针废弃
return 0;
}
当然，事实上还是有一些区别的，比如说C++中，这里的t仍然可以复用，而rust中它就是完全不可再用的状态（除非定义重影，这个语法后续章节详细讨论）。
对于一些C++程序员来说，可能会把rust的这种「移动语义」与C++中的「移动语义」混淆，甚至可能认为「rust的赋值相当于自带std::move」，但其实并非如此，一来std::move是为了触发移动构造/赋值函数，从而触发浅复制，而rust的赋值中根本没有任何复制的语义，而是「所有权转交」；二来std::move并不能使原本的指针失效，但rust中的赋值是可以的，这一点希望读者一定要区分。
如果一定要与C++的语法做对比，rust的行为倒是更加符合std::unique_ptr的行为，unique_ptr不可复制只可移动，移动时转交对象所有权，原本的指针清空：
void Demo() {
auto t = std::make_unique<Test>(1, 2); // 对象部署在堆中，栈上用指针指向
auto t2 = std::move(t); // 赋值时做所有权转交
// 这时t已经被清空了，不再指向原始对象
t->a = 8; // ERROR
}
当然，rust的机制更先进一些，一个是它不用套壳，不需要理解所谓智能指针和std::move的概念，二来如果对已经释放的指针做操作，报错是在编译阶段，而如果是C++的unique_ptr（例如上面例程），报错则是在运行阶段，而且报的是解空指针错误。
Rust的一个世界观
相信很多读者会对rust的所有权转交这一机制非常不适应，甚至非常不解。那么这里我们就不得不讨论一下Rust的一个重点世界观，就是手Rust希望「尽可能在编译阶段发现和避免更多的潜在问题」。也就是说，Rust它不希望程序问题留给运行期，而是在编译期，就把可能会出现的一些错误都发现（或者干脆避免掉）。
因此，每当我们发现一些Rust奇怪的限制或机制的时候，都应当思考这样限制所希望避免的问题。下面用C++来举几个例子，读者可以体会一下传统的复制语义在这里会出现的问题：
示例1：
void f1(Obj obj) {
// 使用obj做一些事情
}
void Demo() {
Obj pre_obj;
f1(pre_obj); // 构造pre_obj只是为了传给f1
// 后面也不会使用pre_obj
}
上面这种场景下，我们在Demo中构造pre_obj，只是为了传给f1使用，但如果f1使用了复制语义，那么就会平白多一次无意义的复制，如果Obj类型比较大，或者是拷贝构造比较复杂，那么这里的效率就会很低。
示例2：
void f1(Obj &&obj) { // 右值引用类型，希望强制获取所有权
// 使用obj做一些事情
}
void Demo() {
Obj pre_obj;
f1(std::move(pre_obj));
// 照理说后边不可以再使用pre_obj，但这是软约束
pre_obj.set_xxx(yyy); // OK不会报错
}
上面这个例子中，尽管我们用了右值引用，「企图」让外界传参时把obj的「所有权」交给函数内部，但在C++中这种移动语义是一种软约束，如果不小心在外界操作了pre_obj仍然是合法的。
示例3：
class Test {
public:
Test(int a): pa_(new int(a)) {}
~Test() {delete pa_;}
private:
int *pa_;
};
void Demo() {
Test t1(1);
Test t2 = t1;
} // 析构时出现重复delete问题
上面这个例子中，我们实现Test类，虽然遵从了构造时new析构时delete的原则，但却没有考虑到复制语义的问题，由于t2是t1的一个浅复制，因此在函数结束时，t1和t2都会对同一片堆空间进行delete。
Rust的世界观中，为了避免这些乱七八糟的内存分配和释放问题，干脆直接在语义上杜绝了这种影响。首先，自定义类型只能部署在堆空间，就不存在浅复制的问题；其次，栈上的变量同时只能有一个持有对象，也不会存在重复释放的问题；最后，由于栈变量和堆对象是1对1的关系，那么他们的生命周期可以做强绑定，也就是说当栈变量释放时，所持有的堆空间就进行析构。
struct Point {
x: f32,
y: f32
}
fn Demo() {
let p1 = Point{x: 0.5, y: 1.2}; // p1持有对象
let p2 = p1; // p2持有对象，p1不再可用
} // p2生命周期结束，对象同时释放
上例中，由于Point对象只能被一个变量持有，当p1交接给p2后，p1就跟这个对象没关系了。后面当p2结束时，自然也不会有其他变量持有这个对象，当然可以放心把它释放。
所以看出来了吗？Rust为什么不需要垃圾回收机制，也不需要什么引用计数器，就能做到避免内存泄漏或者重复释放？答案很简单，因为它根本不允许多重引用。
借用
上一节我们讲解了Rust中自定义类型的所有权问题，相信大家应该能够意识到，这种语言特性在很多场景下是很不方便的。
举例来说，在一个程序流程中，我需要先检验一下输入的参数是否合法，然后再对数据做一些处理。比如说：
struct Data {
dt1: i32,
dt2: u32
}
fn check_args(dt: Data)->bool {
// 判断dt1和dt2要非0
dt.dt1 != 0 && dt.dt2 != 0
}
fn main() {
let mut dt = Data{dt1: 1, dt2: 3};
// 先检查数据
if !check_args(dt) {
// 一些处理
} else {
// 后续逻辑
dt.dt1 += 5; // ERROR
}
}
如果按照上面这种写法，在检查完参数以后，这个dt的所有权就转交了，然后在check_args函数结束后就被释放了，这显然是不符合预期的。同时编译也会报错。
但仔细分析这种场景，这里有一个非常重要的特点，就是说在check_args中，dt相当于只读，不会对其做任何更改。那么也就是说，check_args的调用不会改变dt的值，而且因为只是做检查，因此原本的dt后续还需要使用的。
那么这种场景下并不应当「转交所有权」，而是应当「借用」一下dt。所谓「借用」，形象来说就相当于借别人东西，你只是在借用的过程中可以使用而已，但东西还是人家的，用完了要还回去，并且，你使用的过程中不能损坏。
C++解决这个问题的办法是常引用做参数，这样一来不用复制，二来内部不可改变。
// 用常引用解决问题
bool check_args(const Data &dt) {
return dt.dt1 != 0 && dt.dt2 != 0;
}
int main() {
Data dt {1, 3};
if (!check_args(dt)) {
// ...
} else {
// ...
dt.dt1 = 5;
}
return 0;
}
无独有偶，Rust中解决这个问题的办法也是利用引用，而且是不可变引用。
fn check_args(dt: &Data)->bool {
// 判断dt1和dt2要非0
dt.dt1 != 0 && dt.dt2 != 0
}
fn main() {
let mut dt = Data{dt1: 1, dt2: 3};
// 先检查数据
if !check_args(&dt) { // 注意传参时要显式取引用
// 一些处理
} else {
// 后续逻辑
dt.dt1 += 5; // OK
}
}
前面章节我们已经初步介绍过引用，他有点像C++中引用和指针的结合体，所以这里用作引用传参时也一定要注意，要显式用&表示取引用，这一点与C++不同。
【未完，更新中……】
