在进入正题之前，大家先回忆下一般的编程语言知识。 对于一般的编程语言，通常会先声明一个变量，然后初始化它。 例如在C语言中：
int* foo() {
int a; // 变量a的作用域开始
a = 100;
char *c = "xyz"; // 变量c的作用域开始
return &a;
} // 变量a和c的作用域结束尽管可以编译通过，但这是一段非常糟糕的代码，现实中我相信大家都不会这么去写。变量a和c都是局部变量，函数结束后将局部变量a的地址返回，但局部变量a存在栈中，在离开作用域后，局部变量所申请的栈上内存都会被系统回收，从而造成了Dangling Pointer的问题。这是一个非常典型的内存安全问题。很多编程语言都存在类似这样的内存安全问题。再来看变量c，c的值是常量字符串，存储于常量区，可能这个函数我们只调用了一次，我们可能不再想使用这个字符串，但xyz只有当整个程序结束后系统才能回收这片内存，这点让程序员是不是也很无奈？
备注：对于
xyz，可根据实际情况，通过堆的方式，手动管理（申请和释放）内存。
所以，内存安全和内存管理通常是程序员眼中的两大头疼问题。令人兴奋的是，Rust却不再让你担心内存安全问题，也不用再操心内存管理的麻烦，那Rust是如何做到这一点的？请往下看。
重要：首先必须强调下，准确地说Rust中并没有变量这一概念，而应该称为标识符，目标资源(内存，存放value)绑定到这个标识符：
{
let x: i32; // 标识符x, 没有绑定任何资源
let y: i32 = 100; // 标识符y，绑定资源100
}好了，我们继续看下以下一段Rust代码：
{
let a: i32;
println!("{}", a);
}上面定义了一个i32类型的标识符a，如果你直接println!，你会收到一个error报错：
error: use of possibly uninitialized variable:
a
这是因为Rust并不会像其他语言一样可以为变量默认初始化值，Rust明确规定变量的初始值必须由程序员自己决定。
正确的做法：
{
let a: i32;
a = 100; //必须初始化a
println!("{}", a);
}其实，let关键字并不只是声明变量的意思，它还有一层特殊且重要的概念-绑定。通俗的讲，let关键字可以把一个标识符和一段内存区域做“绑定”，绑定后，这段内存就被这个标识符所拥有，这个标识符也成为这段内存的唯一所有者。
所以，a = 100发生了这么几个动作，首先在栈内存上分配一个i32的资源，并填充值100，随后，把这个资源与a做绑定，让a成为资源的所有者(Owner)。
像C语言一样，Rust通过{}大括号定义作用域：
{
{
let a: i32 = 100;
}
println!("{}", a);
}编译后会得到如下error错误：
b.rs:3:20: 3:21 error: unresolved name
a[E0425] b.rs:3 println!("{}", a);
像C语言一样，在局部变量离开作用域后，变量随即会被销毁；但不同是，Rust会连同变量绑定的内存，不管是否为常量字符串，连同所有者变量一起被销毁释放。所以上面的例子，a销毁后再次访问a就会提示无法找到变量a的错误。这些所有的一切都是在编译过程中完成的。
先看如下代码：
{
let a: String = String::from("xyz");
let b = a;
println!("{}", a);
}编译后会得到如下的报错：
c.rs:4:20: 4:21 error: use of moved value:
a[E0382] c.rs:4 println!("{}", a);
错误的意思是在println中访问了被moved的变量a。那为什么会有这种报错呢？具体含义是什么？
在Rust中，和“绑定”概念相辅相成的另一个机制就是“转移move所有权”，意思是，可以把资源的所有权(ownership)从一个绑定转移（move）成另一个绑定，这个操作同样通过let关键字完成，和绑定不同的是，=两边的左值和右值均为两个标识符：
语法：
let 标识符A = 标识符B; // 把“B”绑定资源的所有权转移给“A”move前后的内存示意如下：
Before move:
a <=> 内存(地址：A，内容："xyz")
After move:
a
b <=> 内存(地址：A，内容："xyz")
被move的变量不可以继续被使用。否则提示错误error: use of moved value。
这里有些人可能会疑问，move后，如果变量A和变量B离开作用域，所对应的内存会不会造成“Double Free”的问题？答案是否定的，Rust规定，只有资源的所有者销毁后才释放内存，而无论这个资源是否被多次move，同一时刻只有一个owner，所以该资源的内存也只会被free一次。
通过这个机制，就保证了内存安全。是不是觉得很强大？
有读者仿照“move”小节中的例子写了下面一个例子，然后说“a被move后是可以访问的”：
let a: i32 = 100;
let b = a;
println!("{}", a);编译确实可以通过，输出为100。这是为什么呢，是不是跟move小节里的结论相悖了？
其实不然，这其实是根据变量类型是否实现Copy特性决定的。对于实现Copy特性的变量，在move时会拷贝资源到新内存区域，并把新内存区域的资源binding为b。
Before move:
a <=> 内存(地址：A，内容：100)
After move:
a <=> 内存(地址：A，内容：100)
b <=> 内存(地址：B，内容：100)
move前后的a和b对应资源内存的地址不同。
在Rust中，基本数据类型(Primitive Types)均实现了Copy特性，包括i8, i16, i32, i64, usize, u8, u16, u32, u64, f32, f64, (), bool, char等等。其他支持Copy的数据类型可以参考官方文档的Copy章节。
前面例子中move String和i32用法的差异，其实和很多面向对象编程语言中“浅拷贝”和“深拷贝”的区别类似。对于基本数据类型来说，“深拷贝”和“浅拷贝“产生的效果相同。对于引用对象类型来说，”浅拷贝“更像仅仅拷贝了对象的内存地址。
如果我们想实现对String的”深拷贝“怎么办？ 可以直接调用String的Clone特性实现对内存的值拷贝而不是简单的地址拷贝。
{
let a: String = String::from("xyz");
let b = a.clone(); // <-注意此处的clone
println!("{}", a);
}这个时候可以编译通过，并且成功打印"xyz"。
clone后的效果等同如下：
Before move:
a <=> 内存(地址：A，内容："xyz")
After move:
a <=> 内存(地址：A，内容："xyz")
b <=> 内存(地址：B，内容："xyz")
注意，然后a和b对应的资源值相同，但是内存地址并不一样。
通过上面，我们已经已经了解了变量声明、值绑定、以及移动move语义等等相关知识，但是还没有进行过修改变量值这么简单的操作，在其他语言中看似简单到不值得一提的事却在Rust中暗藏玄机。 按照其他编程语言思维，修改一个变量的值：
let a: i32 = 100;
a = 200;很抱歉，这么简单的操作依然还会报错：
error: re-assignment of immutable variable
a[E0384] :3 a = 200;
不能对不可变绑定赋值。如果要修改值，必须用关键字mut声明绑定为可变的：
let mut a: i32 = 100; // 通过关键字mut声明a是可变的
a = 200;想到“不可变”我们第一时间想到了const常量，但不可变绑定与const常量是完全不同的两种概念；首先，“不可变”准确地应该称为“不可变绑定”，是用来约束绑定行为的，“不可变绑定”后不能通过原“所有者”更改资源内容。
例如：
let a = vec![1, 2, 3]; //不可变绑定, a <=> 内存区域A(1,2,3)
let mut a = a; //可变绑定， a <=> 内存区域A(1,2,3), 注意此a已非上句a，只是名字一样而已
a.push(4);
println!("{:?}", a); //打印：[1, 2, 3, 4]“可变绑定”后，目标内存还是同一块，只不过，可以通过新绑定的a去修改这片内存了。
let mut a: &str = "abc"; //可变绑定, a <=> 内存区域A("abc")
a = "xyz"; //绑定到另一内存区域, a <=> 内存区域B("xyz")
println!("{:?}", a); //打印："xyz"上面这种情况不要混淆了，a = "xyz"表示a绑定目标资源发生了变化。
其实，Rust中也有const常量，常量不存在“绑定”之说，和其他语言的常量含义相同：
const PI:f32 = 3.14;可变性的目的就是严格区分绑定的可变性，以便编译器可以更好的优化，也提高了内存安全性。
在前面的小节有简单了解Copy特性，接下来我们来深入了解下这个特性。 Copy特性定义在标准库std::marker::Copy中：
pub trait Copy: Clone { }一旦一种类型实现了Copy特性，这就意味着这种类型可以通过的简单的位(bits)拷贝实现拷贝。从前面知识我们知道“绑定”存在move语义（所有权转移），但是，一旦这种类型实现了Copy特性，会先拷贝内容到新内存区域，然后把新内存区域和这个标识符做绑定。
哪些情况下我们自定义的类型（如某个Struct等）可以实现Copy特性？ 只要这种类型的属性类型都实现了Copy特性，那么这个类型就可以实现Copy特性。 例如：
struct Foo { //可实现Copy特性
a: i32,
b: bool,
}
struct Bar { //不可实现Copy特性
l: Vec<i32>,
}因为Foo的属性a和b的类型i32和bool均实现了Copy特性，所以Foo也是可以实现Copy特性的。但对于Bar来说，它的属性l是Vec<T>类型，这种类型并没有实现Copy特性，所以Bar也是无法实现Copy特性的。
那么我们如何来实现Copy特性呢？
有两种方式可以实现。
-
通过
derive让Rust编译器自动实现#[derive(Copy, Clone)] struct Foo { a: i32, b: bool, }
编译器会自动检查
Foo的所有属性是否实现了Copy特性，一旦检查通过，便会为Foo自动实现Copy特性。 -
手动实现
Clone和Copytrait#[derive(Debug)] struct Foo { a: i32, b: bool, } impl Copy for Foo {} impl Clone for Foo { fn clone(&self) -> Foo { Foo{a: self.a, b: self.b} } } fn main() { let x = Foo{ a: 100, b: true}; let mut y = x; y.b = false; println!("{:?}", x); //打印：Foo { a: 100, b: true } println!("{:?}", y); //打印：Foo { a: 100, b: false } }
从结果我们发现
let mut y = x后，x并没有因为所有权move而出现不可访问错误。 因为Foo继承了Copy特性和Clone特性，所以例子中我们实现了这两个特性。
我们从前面的小节了解到，let绑定会发生所有权转移的情况，但ownership转移却因为资源类型是否实现Copy特性而行为不同：
let x: T = something;
let y = x;- 类型
T没有实现Copy特性：x所有权转移到y。 - 类型
T实现了Copy特性：拷贝x所绑定的资源为新资源，并把新资源的所有权绑定给y，x依然拥有原资源的所有权。
move关键字常用在闭包中，强制闭包获取所有权。
例子1：
fn main() {
let x: i32 = 100;
let some_closure = move |i: i32| i + x;
let y = some_closure(2);
println!("x={}, y={}", x, y);
}结果： x=100, y=102
注意: 例子1是比较特别的，使不使用 move 对结果都没什么影响，因为x绑定的资源是i32类型，属于 primitive type，实现了 Copy trait，所以在闭包使用 move 的时候，是先 copy 了x ，在 move 的时候是 move 了这份 clone 的 x，所以后面的 println!引用 x 的时候没有报错。
例子2：
fn main() {
let mut x: String = String::from("abc");
let mut some_closure = move |c: char| x.push(c);
let y = some_closure('d');
println!("x={:?}", x);
}报错： error: use of moved value:
x[E0382] :5 println!("x={:?}", x);
这是因为move关键字，会把闭包中的外部变量的所有权move到包体内，发生了所有权转移的问题，所以println访问x会如上错误。如果我们去掉println就可以编译通过。
那么，如果我们想在包体外依然访问x，即x不失去所有权，怎么办？
fn main() {
let mut x: String = String::from("abc");
{
let mut some_closure = |c: char| x.push(c);
some_closure('d');
}
println!("x={:?}", x); //成功打印：x="abcd"
}我们只是去掉了move，去掉move后，包体内就会对x进行了可变借用，而不是“剥夺”x的所有权，细心的同学还注意到我们在前后还加了{}大括号作用域，是为了作用域结束后让可变借用失效，这样println才可以成功访问并打印我们期待的内容。
关于“Borrowing借用”知识我们会在下一个大节中详细讲解。