所有权对大多数开发者而言是一个新颖的概念,它是 Rust 语言为高效使用内存而设计的语法机制。所有权概念是为了让 Rust 在编译阶段更有效地分析内存资源的有用性以实现内存管理而诞生的概念。
计算机程序必须在运行时管理它们所使用的内存资源
所有权有以下三条规则:
从C/C++的角度来讲就是,变量有其作用范围,而且一个变量名对应一个变量的值;超过变量作用范围,该值就失效了。
变量范围是变量的一个属性,其代表变量的可行域,默认从声明变量开始有效直到变量所在域结束。
如果我们定义了一个变量并给它赋予一个值,则这个变量的值存在于内存中。这种情况很普遍,但如果我们需要储存的数据长度不确定(比如用户输入的一串字符串),我们就无法在定义时明确数据长度,也就无法在编译阶段令程序分配固定长度的内存空间供数据储存使用。(有人说分配尽可能大的空间可以解决问题,但这个方法很不文明)。这就需要提供一种在程序运行时程序自己申请使用内存的机制——堆。
有分配就有释放,程序不能一直占用某个内存资源。因此决定资源是否浪费的关键因素就是资源有没有及时的释放。
用 C++代码举例:
int n = 0;
cin >> n;
int* arr = new int[n];
delete []arr;
很显然,Rust 里没有delete
函数来释放arr的内存资源。而Rust 之所以没有明示释放的步骤是因为在变量范围结束的时候,Rust 编译器自动添加了调用释放资源函数的步骤。别小看这一个自动调用释放资源的机制,这种简单的机制可以有效地解决一个史上最令程序员头疼的编程问题。
变量与数据交互方式主要有移动(Move)和克隆(Clone)两种:
let x = 5; let y = x;
let s1 = String::from("hello");
let s2 = s1;
实例:
fn main() {
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);
}
这里是真的将堆中的 “hello” 复制了一份,所以 s1 和 s2 都分别绑定了一个值,释放的时候也会被当作两个资源。
当然,克隆仅在需要复制的情况下使用,毕竟复制数据会花费更多的时间。
我们直接用代码解释:
fn main() {
let s = String::from("hello");
// s 被声明有效
takes_ownership(s);
// s 的值被当作参数传入函数
// 所以可以当作 s 已经被移动,从这里开始已经无效
let x = 5;
// x 被声明有效
makes_copy(x);
// x 的值被当作参数传入函数
// 但 x 是基本类型,依然有效
// 在这里依然可以使用 x 却不能使用 s
} // 函数结束, x 无效, 然后是 s. 但 s 已被移动, 所以不用被释放
fn takes_ownership(some_string: String) {
// 一个 String 参数 some_string 传入,有效
println!("{}", some_string);
} // 函数结束, 参数 some_string 在这里释放
fn makes_copy(some_integer: i32) {
// 一个 i32 参数 some_integer 传入,有效
println!("{}", some_integer);
} // 函数结束, 参数 some_integer 是基本类型, 无需释放
上实例:
fn main() {
let s1 = gives_ownership();
// gives_ownership 移动它的返回值到 s1
let s2 = String::from("hello");
// s2 被声明有效
let s3 = takes_and_gives_back(s2);
// s2 被当作参数移动, s3 获得返回值所有权
} // s3 无效被释放, s2 被移动, s1 无效被释放.
fn gives_ownership() -> String {
let some_string = String::from("hello");
// some_string 被声明有效
return some_string;
// some_string 被当作返回值移动出函数
}
fn takes_and_gives_back(a_string: String) -> String {
// a_string 被声明有效
a_string // a_string 被当作返回值移出函数
}
被当作函数返回值的变量所有权将会被移动出函数并返回到调用函数的地方,而不会直接被无效释放。
Rust 语言也是支持引用的,这个知识点对于C++开发者来说可谓是非常熟悉,引用实质上是一种指针,具体来说是一个指针常量。
我们可以把引用理解为访问变量的间接方式:
fn main() {
let s1 = String::from("hello");
let s2 = &s1;
println!("s1 is {}, s2 is {}", s1, s2);
}
//变量本身不会被认定无效,可以访问s1,因为"引用"并没有在栈中复制变量的值
在函数中,传入变量的引用只需加上&
即可:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
s.len()
}
运行结果:The length of 'hello' is 5.
关于引用时所有权的问题:
例如:
let s1 = String::from("hello");
let mut s2 = &s1; //因为s2租借多次,所以需要加mut
let s3 = s1;
s2 = &s3; //重新从 s3 租借所有权
例如:
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);
这段程序不正确,因为多重可变引用了 s。
Rust 对可变引用的这种设计主要出于对并发状态下发生数据访问碰撞的考虑,在编译阶段就避免了这种事情的发生。
由于发生数据访问碰撞的必要条件之一是数据被至少一个使用者写且同时被至少一个其他使用者读或写,所以在一个值被可变引用时不允许再次被任何引用。
垂悬引用(Dangling References)
在C/C++等有指针概念的语言里,会存在空指针和野指针的异常,其实这种异常指的是那种没有实际指向一个真正能访问的数据的指针。它们就像失去悬挂物体的绳子,所以叫"垂悬引用" 。
下面是一个垂悬的典型案例:
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}
主函数调用
dangle
函数,该函数定义了一个局部变量s
,函数结束时返回的该变量的引用;但是该变量本身并没有当作返回值,而是超过作用域后被释放,那么此时的引用的指向已经无法确定是否存在,因此不允许存在。
这个原理跟C++中不能返回局部变量的地址是同一个知识点。
注:本篇博客讲的内存资源都是指堆所占用的内存空间