带你了解 Rust 中的move, copy, clone
move, copy, clone
原文：https://hashrust.com/blog/moves-copies-and-clones-in-rust/
本文对
move, copy, clone不做中文翻译，保持在Rust中的味道，翻译了就没哪味。
介绍
移动和复制是Rust中的基本概念。对于来自Ruby、Python或C#等具有垃圾回收功能语言的开发者来说，这些概念可能是完全陌生的。虽然这些术语在c++中是存在的，但它们在Rust中的含义略有不同。在这篇文章中，我将解释在Rust中move、copy和clone的含义。就让我们一探究竟吧。
Move
正如「Rust中的内存安全 — 2」所说的，将一个变量赋值给另一个变量会将所有权转移。
let v: Vec<i32> = Vec::new();
let v1 = v; // v1 is the new owner
在上述例子中，v被移到了v1上。但移动v是什么意思？为了理解这一点，我们需要看看Vec在内存中的布局结构：
Vec内部维护一个动态增长或收缩的缓冲区。这个缓冲区是在堆上分配的，包含Vec的实际元素。此外，Vec在栈上还有一个小对象。这个对象包含一些管理信息:一个指向堆上缓冲区的指针，缓冲区的容量和长度(即当前有多少部分已经被填满)。
当变量v被移动到v1时，栈上的对象按位复制(stack copy):
📒 :
在上面的例子中，实际上发生的是一个浅拷贝(也就是按位复制)。这与c++截然不同，c++在执行一个vector赋值给另一个变量时会进行深拷贝。
堆上的缓冲区保持不变。但这里发生了一次移动：现在是v1负责释放堆上缓冲区，而不是v:
let v: Vec<i32> = Vec::new();
let v1 = v;
println!("v's length is {}", v.len()); // error: borrow of moved value: `v`
这种所有权的改变是有益的，因为如果同时允许通过v和v1访问缓冲区数据，那么你将会得到两个栈对象指向同一个堆缓冲区:
在这种情况下，哪个对象有权释放缓冲区？这点并不清楚，而Rust从根本就防止了这种情况的出现。(即：赋值 → 栈对象拷贝，同时转移所有权，保证一个对象在同一时间只能有一个所有者)
当然，赋值并不是唯一涉及移动的操作。值在作为参数传递或从函数返回时也会被移动:
let v: Vec<i32> = Vec::new();
// v is first moved into print_len's v1
// and then moved into v2 when print_len returns it
let v2 = print_len(v);
fn print_len(v1:Vec<i32>) ->Vec<i32> {
println!("v1's length is {}", v1.len());
v1 // v1 is moved out of the function
}
或是赋给结构体或enum的成员:
struct Numbers {
nums:Vec<i32>
}
let v: Vec<i32> = Vec::new();
// v moved into nums field of the Numbers struct
let n = Numbers { nums: v };
enum NothingOrString {
Nothing,
Str(String)
}
let s: String = "I am moving soon".to_string();
// s moved into the enum
let nos = NothingOrString::Str(s);
这都是关于move的内容。接下来让我们看看copy。
Copy
还记得上面的例子吗?
let v: Vec<i32> = Vec::new();
let v1 = v;
println!("v's length is {}", v.len()); //error: borrow of moved value: `v`
如果我们把变量v和v1的类型从Vec改为i32，会发生什么呢?
let v: i32 = 42;
let v1 = v;
println!("v is {}", v); // compiles fine, no error!
这几乎是相同的代码。为什么赋值操作这次不把v移到v1中呢？为了了解这一点，让我们再次看看堆栈中的内存布局:
在本例中，值是完全只存储在栈中。堆上没有东西可以拥有。这就是为什么允许通过v和v1访问是可以的 —— 因为它们是完全独立的拷贝。
这种不拥有其他资源并且可以按位复制的类型称为复制类型。它们实现了 Copy Trait。目前所有基本类型，如整数、浮点数和字符都是Copy类型。默认情况下，struct/enum 不是Copy，但你可以派生 Copy trait:
#[derive(Copy, Clone)]
struct Point {
x: i32,
y: i32,
}
#[derive(Copy, Clone)]
enum SignedOrUnsignedInt {
Signed(i32),
Unsigned(u32),
}
📒 :
需要在#[derive()]中同时使用Clone，因为Copy是这样定义的:pub trait Copy: Clone {}
但是要使 #[derive(Copy, Clone)] 起作用，struct或enum的所有成员必须可以 Copy。例如，下面代码就不起作用:
// error:the trait `Copy` may not be implemented for this type
// because its nums field does not implement `Copy`
#[derive(Copy, Clone)]
struct Numbers {
nums: Vec<i32>
}
当然，你也可以手动实现 Copy 和 Clone:
struct Point {
x: i32,
y: i32,
}
// marker trait
implCopy for Point {}
implClone for Point {
fn clone(&self) -> Point {
*self
}
}
📒 :
marker trait→ 本身没有任何行为，但被用于给编译器提供某些保证。具体可以看这里
但是一般来说，任何实现 Drop 的类型都不能被 Copy，因为 Drop 是由拥有一些资源的类型实现的。因为不能被简单地按位复制，但是Copy类型应该是可以被简单复制的。因此，Drop和Copy不能很好地混合。
这就是关于 Copy 的全部内容。接下来是 Clone。
Clone
当一个值被移动时，Rust会做一个浅拷贝；但是如果你想创建一个像C++那样的深拷贝呢？
为了实现这一点，一个类型必须首先得实现 Clone Trait。然后，为了能进行深复制，调用端代码应该执行 clone()：
let v: Vec<i32> = Vec::new();
let v1 = v.clone(); // ok since Vec implements Clone
println!("v's length is {}", v.len());//ok
clone() 调用后，内存布局如下:
由于深拷贝，v和v1都可以自由独立地释放它们对应的堆缓冲区数据。
📒 :
clone()并不总是创建深拷贝。类型可以自由地以任何他们想要的方式实现clone()，但在语义上它应该足够接近复制一个对象的含义。例如，Rc/Arc会增加引用计数。
这就是关于 Clone 的所有内容。
总结
在这篇文章中，我深入分析了Rust中的 Move/Copy/Clone 的语义。同时在文章中试图捕捉与C++中，在语义上的细微差别。
Rust之所以优秀，是因为它有大量的默认行为。例如，Rust中的赋值操作符要么移动值(转移所有权)，要么进行简单的按位复制(浅拷贝)。
另一方面，在c++中，看似无害的赋值操作可以隐藏大量的代码，而这些代码作为重载赋值运算符的一部分运行。在Rust中，这样的代码是公开的，因为程序员必须显式地调用 clone()。
有人可能会说，这两种语言做出了不同的权衡，但我喜欢Rust由于这些设计权衡而带来的额外安全保障。
如果想了解更多，可以关注公众号： Databend
