先序文章请看:
面向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++不同。
【未完,更新中……】