写给rust初学者的教程（二）：所有权、生存期
这系列RUST教程一共三篇。这是第二篇，介绍RUST语言的关键概念，主要是所有权和生存期等。
在写第一篇中的练习代码时，不知道你有没有尝试过连续两次执行vec_min函数。这种做法在大部分其他语言中都属于正常行为，但如果你对rust这样做了，立即就得到一个error，编译都通不过：
“值在被移走后用掉了”！怎么会这样？
rust的宗旨是内存安全。为了实现这个任务，rust指定了一条铁律：通过别名访问数据时不能修改数据。这就是大名鼎鼎的“所有权”！
实际上这就是内存安全问题的根源：可变性以及起别名。可以看一下这些文章：Aliasing is what makes mutable types risky (Java)， Aliasing and “Mutation at a Distance” （Python）
ownership
为什么要这样呢？我们通过一段C++程序来看这个问题：
void foo(std::vector<int> v) {
int *first = &v[0];
v.push_back(42);
*first = 1337;
}
传统程序里面，C++的内存需要我们程序员来管理。这里变量first指向了参数v的首地址，然后给这个数组插入一个新元素；如果插入的时候数组是满的，v就会指向一个新的更大的数组，这样first指向的内存实际是无效的了。这就是超名昭著的“悬垂指针”问题。
那rust怎么做的呢？
看一个小程序：
fn handle_vector(v: Vec<i32>) { }
fn ownership_test() {
let v = vec![1,2,3,4];
handle_vector(v);
println!("{}", v[0]);
}
肉眼看这个程序好像非常正常，但是给cargo build瞅了一眼，它说最后一句有问题，编译不了！ Son of a biscuit.
rust中，当你把一个变量传到其他函数中时，rust认为你主动出让了所有权，出让后你就再也不能访问这个变量了。在其他函数执行完成后，这个传进去的变量处的内存会被回收掉。如果允许你访问，就和上面说的“悬垂指针”一样的问题了。
那这和上面说的所有权规则有啥关系？所有权规则是：通过其他别名访问数据时不可修改。可是传给其他函数后（必然会起别名），数据可能被修改了，所以你就不能再访问了。
可是Java里面就是这样传进去的啊！也没出问题啊
rust也能实现Java这样的效果。——当然能，必须能；如果不能，我相信没人会使用rust了。
还是以我们的vec_min函数为例，来看一下rust中的引用“借用”。
&
目前的函数签名是这样的：
fn vec_min<T: Minimum>(vec: Vec<T>) -> SomethingOrNothing<T> {}
假设你有一部iPad，你的朋友们都可以借用它来浏览网页，用完还给你，期间他的朋友可能也会借用一会；但是他们借走期间，你没法使用它了 —— 当然是这样，毕竟我们也遵循“泡利不相容原理”，噗。
rust也模仿的这种现实：传递参数时可以指明是在“borrowing”而非“moving”。之前我们写的代码都是对所有权进行了move，要改成borrow需要在参数类型前面增加一个&。
fn vec_min<T: Minimum>(vec: &Vec<T>) -> SomethingOrNothing<T> {}
现在vec不再是集合类型了，而是&Vec类型。要想拿到引用对应的变量值，需要使用解引用符号*：
fn vec_min<T: Minimum>(vec: &Vec<T>) -> SomethingOrNothing<T> {
let mut min = Nothing;
for e in vec {
min = Something(match min {
Something(i) => { e.compare(i) }
Nothing => { *e }
})
}
min
}
这里还涉及两处其他的改动：
- 你可以通过观察或者运行来发现，为什么
e是一个引用类型，但是只有Nothing的分支进行了解引用，Something分支却直接调用了它的compare方法。所以这里需要去修改comapre方法，将第一个参数self改成&self
pub trait Minimum : Copy {
fn compare(&self, s: Self) -> Self;
}
impl Minimum for i32 {
fn compare(&self, s: Self) -> Self {
if *self < s { *self } else { s }
}
}
相应的，实现的地方在返回的时候也要判断，返回self就使用*self，返回s则不用加*。
- 第二个问题比较难发现，需要给元素类型实现
Copy特征，上面代码中已经增加了。
现在你可以试一下了，调用两次vec_min并不会报错了。
&mut
借出去的所有权，数据可以被修改吗？
是可以的。
你可以尝试在vec_min中给参数中push或者remove。应该会报错，根据错误信息响应的调整代码即可。你会发现，参数类型前面也可以加mut，变成了这样：
fn vec_min<T: Minimum>(vec: &mut Vec<T>) -> SomethingOrNothing<T> {}
甚至这样写：
for e in v.iter_mut() {
*e += 1;
}
但是由于是引用类型，并不能赋值。你可以在调用前多次vec = vec![2];vec = vec![3];，但是在vec_min里面却不能执行这样的语句。
借用引用和可变引用
上面说的实际是两种不同的引用类型。rust中严格区分了他们。跟编程中的加锁一样，借用引用（用&来开启）同一时刻是可以存在多个的，他们互相不影响，因为只有读操作 —— 就和读锁一样；而可变引用（用&mut开启）同一时刻只能存在一个，而且使用了可变引用就不能使用借用引用了，因为什么？“不可重复读”。所以可变引用就是排它锁，可以称为 唯一引用 。
再来一个例子。
这次我们构造一个对象，类似于Java中的BigInteger。这种对象能够表示非常大的数，内存有多大数就有多大（哈哈😄），因为里面是用数组的多个元素来存储的。
自定义类型的创建使用struct关键字。
struct
struct和C中的结构体几乎一样，就是用来定义一个新类型的：
pub struct BigInteger {
data: Vec<u8>,
}
我给这个struct前置了pub，但是字段data没加，所以这个字段是私有的。然后通过getter和setter来访问它：
impl BigInteger {
pub fn get_data(&self) -> &Vec<u8> {
&self.data
}
pub fn set_data(&mut self, data: Vec<u8>) {
self.data = data;
}
}
getter中的参数是借用引用，因为只是读没有写；setter中的self参数是可变引用，因为要覆盖data字段。
这个对象的字段类型是Vec<u8>。u8是8位长度的无符号类型，前面使用的i32是32位的有符号类型。这里当然使用任何整数类型都可以，我们只是用数组来存储大整数的每一位，所以实际上4位就足够了。因为一位数最大是9，4位二进制可以表示16。而8位整数是rust提供的最短整数了，所以我选择了u8，你也可以用i8来提供存储负数的能力（但是可能会有问题，你需要更多的防护代码，来防止中间的数字是负数）。
u8能表示的最大数已经是256了，所以超过9的时候要记得判断
一个常见的经验做法就是从个位开始存储大数，因为你不能确定大数的位数，计算起来不对齐的话就十分困难。比如一个数1459，我们放在Vec中是先放9，然后依次是5,4,1。这样我们计算的时候就可以从开始取到个位数开始算。由此引出的另一个经验做法就是，数组中不能存前置0。虽然给一个数增加几个前置0都不改变大小，但是会影响我们的存储和计算判断。
impl BigInteger {
pub fn default() -> Self {
BigInteger {data: vec![0]}
}
pub fn test_invariant(&self) -> bool {
if self.data.len() <= 1 {
true
} else {
self.data[self.data.len() - 1] != 0
}
}
pub fn from_vec(mut v: Vec<u8>) -> Self {
let mut p = v.pop();
while p.is_some() && p.unwrap() == 0 {
p = v.pop()
}
if p.is_none() {
return BigInteger::default();
}
v.push(p.unwrap());
let mut data = vec![];
for mut b in v {
data.push(b % 10);
}
BigInteger {data}
}
}
这里给BigInteger增加了三个函数和方法。default和from_vec都是用来创建实例的，不存储其他数据的时候默认是0。from_vec只是把参数复制一遍存起来，但是会去掉末尾的0（对应大数开头的0）：pop方法可以弹出并返回Vec的最后一个元素，并以Option返回。如果参数中有元素不是一位数，可以报错。这里我们只取其个位数（通过除以10取余数）。
test_invariant是个实例方法，用来验证大数是否以0开头。
下面写几个case测试一下：
fn main() {
let mut bi = BigInteger::default();
bi.print();
bi = BigInteger::from_vec(vec![23, 4]);
bi.print();
bi = BigInteger::from_vec(vec![3, 6, 0]);
bi.print();
let data = vec![0, 1 << 7, 0, 0];
let p = data[3];
bi = BigInteger::from_vec(data);
// bi = BigInteger::from_vec(data);
bi.print();
// println!("3 ==> {}, {}", p, data.len());
}
里面的print方法是这样的
impl BigInteger {
pub(crate) fn print(&self) {
print!("stored len: {}, value: ", self.data.len());
let mut index = 0;
while index < self.data.len() {
index += 1;
print!("{}", self.data[self.data.len() - index])
}
println!()
}
}
输出如下
stored len: 1, value: 0
stored len: 2, value: 43
stored len: 2, value: 63
stored len: 2, value: 80
第一个0没啥疑问。第二个是43，因为十位是4，个位取23的个位；第三个去掉末尾的0，所以是63。第四个里面，1 << 7表示左移7位，1变成了128，个位是8，所以是80。
现在类型定义好了，开始正题。
在case中我们看到，第四次定义的参数data传给了函数from_vec。而参数在函数中会被消费掉，发生了所有权转移，所以函数返回后变量data就没用了。你可以把上面代码中注释掉的任何一行放开，都会编译报错。
这可咋办呢？
其实很简单：我们把变量赋值一份传给函数就好了嘛。
clone
由于rust中不变性和所有权的限制，clone操作使用得非常普遍。当然它好带来性能问题，我们后面再说。
可以看到，不适用clone的话，第二次调用函数就会报错；使用了clone自然没问题。
一个对象要想能够被clone，需要实现Clone 特征。Vec已经实现了这个特征。
你可能注意到了，
clone的receiver是一个借用引用，为啥我们没写&呢？不是应该是BigInteger::from_vec((&data).clone());吗？因为如果借用是发生在实例自身上，rust做了特殊处理，让我们可以不写&。
我们给BigInteger也实现这个特征：
impl Clone for BigInteger {
fn clone(&self) -> Self {
BigInteger {data: self.data.clone()}
}
}
简单得不能再简单，复制数据塞进一个新实例中。
再练习一下，给之前的枚举 SomethingOrNothing 实现这个trait:
impl<T: Clone> Clone for SomethingOrNothing<T> {
fn clone(&self) -> Self {
match *self {
Something(ref v) => { Something(v.clone()) }
Nothing => { Nothing }
}
}
}
ref
我们给泛型类型T定义了边界，必须也能clone，否则在第一个分支中我们就不能执行v.clone()了。
前面说过，clone的reciever是一个借用引用。要想把Something中的v设置成借用引用，需要使用ref。
你可以自己试一下改改代码看看效果。
derive
Clone 这个 trait 太常用了，导致rust给他定义了一种更方便的实现方法。我们可以在类型上面写上注解#[derive(Clone)]，rust就自动实现了这个接口：
#[derive(Clone)]
pub struct BigInteger {
data: Vec<u8>,
}
你可以给 SomethingOrNothing 头上写一下看看效果。
attribute
rust 中的这种注解称为“属性”（attribute），能给代码添加元数据，影响编译器的行为或提供其他类型的额外信息。常见的比如有
#[derive(Trait)]： 就是刚才用的，用于自动实现一些常见的trait。#[test]： 属性用于标记一个函数为测试函数。#[inline]：内联优化的提示。- 还有许多用来压制编译器告警的属性，如#[allow(lint_name)]、#[warn(lint_name)]、#[deny(lint_name)]、#[forbid(lint_name)]、#[must_use]等。
- 还有很多其他的属性，有些可能将来能用到，有些可能一辈子也用不上。等着大家去探索。
继续我们的大数类型。
我打算用它做vec_min函数的泛型类型，来求一系列大整数中的最小值。
因为vec_min的泛型类需要实现 trait Minimum，这样才能进行元素对比。我们先给它实现这个特征：
impl Minimum for BigInteger {
fn compare(&self, s: Self) -> Self {
debug_assert!(self.test_invariant());
debug_assert!(s.test_invariant());
if self.data.len() < s.data.len() { self.clone() } else if self.data.len() > s.data.len() { s } else {
let mut data1 = self.data.clone();
let mut other = s.data.clone();
let mut digit1 = data1.pop();
while digit1.is_some() {
let this_digit = digit1.unwrap();
let other_digit = other.pop().unwrap();
if this_digit > other_digit { return s; } else if this_digit < other_digit { return self.clone(); } else {
digit1 = data1.pop()
}
}
s
}
}
}
如果编译器说需要实现父特征Copy，就把
Minimum的父特征删掉，现在有了克隆用不到它了。同时需要修改vec_min方法的Nothing分支变成Nothing => { (*e).clone() }。
首先对每个对比元素进行了一次 debug_assert。这是一个宏，接受一个 bool 类型的参数：参数是true才能继续，否则就 panic。所以我们用它判断每个参数都没有以0开头。
这个宏在打 release 包的时候会被忽略掉，所以只是用于代码调试的
然后对比两个大整数的位数，谁的位数长谁就大，因为有两点保证了这个做法：①非0开头，②非负。
当他们位数一样是，就可以从高位开始比较大小了。我使用 pop 方法拿到集合的最后一个元素，也就是整数的最高位。
最后来测试一下。
let bigs: Vec<BigInteger> = vec![BigInteger::new(3), BigInteger::from_vec(vec![5,1]), BigInteger::default(), BigInteger::new(8)];
vec_min(&bigs).print();
集合中有4个“大”数：3，15， 0， 8。拿到结果后打印出来。但是我们还没实现打印方法，所以给它加上：
type BigIntOrNothing = SomethingOrNothing<BigInteger>;
impl BigIntOrNothing {
fn print(self) {
match self {
Something(n) => { n.print(); }
Nothing => { println!("nothing") }
}
}
}
你自己可以测试几次：每次去掉最小的大数，看剩余的对比结果。
why clone?
这个程序其实挺关键的。如果你不是只是浏览了一下这个程序的实现，而是自己去写了一遍，你可能会疑惑：为什么需要用到这么多的 clone ？无论是在 compare 方法里，还是在 vec_min 函数中。
问题的关键是，这些方法都接受的是引用类型的参数（参数类型都是
&前缀的）。而我们处理或者返回的数据都是拥有所有权的。
你可以反复修改一下用到 clone 地方的代码，看一下编译器如何提示。
等一下！
为什么我们之前没这样啊？之前我们的 vec_min 还不能接受泛型类型，它的元素类型还是 i32。那时候天还蓝的，水还是绿的，拍电影是不用脱衣服的，小孩子的爸爸是谁也是明确的，求最小值还是不用克隆的。
Copy type
rust 中有一些类型，当你移动它的时候移动的并不是所有权，而是数据自身 —— 数据被复制了一份进行移动。前面用到的 i32 就是这种类型，还有 bool 也是。他们 move 的行为和 Vec 这些类型不一样，它们称为 “Copy 类型”。
Copy 是rust中的一个trait。我们常用的整数、小数、字符、布尔等都实现了它
Copy 是一个标记特征（marker trait），它自身没有任何方法，只是一个标记，给编译器用的。Java中也有类似的接口，比如 java.io.Serializable。
实际上，把一个值传给一个函数后，rust执行的时候一定会做一次拷贝，不论参数是i32还是 Vec。只是 Vec 执行的是浅拷贝 （shallow copy），这点和C++很像。不同的是，rust 认为即使是浅拷贝也是破坏性的，所以传值后就不能再使用这个数据了。毕竟只是浅拷贝，它们可能还是共享了内存指针的。但如果参数是拷贝类型，rust就觉得没关系了，不会对原数据造成破坏了。
如果我们自己想要复制对象，请实现 Clone 并主动调用 clone 方法，这样就可以深拷贝对象，因为浅拷贝 rust已经替我们做了。
好了，你可以再休息一下，回味一下刚才的内容。请休息好，因为接下来我们将迎接更大的挑战！这个挑战可是“劝退级”的。
欢迎回来。
我们来看你可能也一直疑惑的地方：rust 对数据所有权进行了这么严格的限制，导致我们不得不频繁使用深拷贝，那性能能好吗？rust 不是以性能标榜自己的吗？
我们回头再来看上面那个悬垂指针的问题：通过深拷贝我们解决了这个问题，但我们不想通过这种方法解决。怎么办？
先回忆一下。看一个例子：
fn first<T>(vec: &Vec<T>) -> Option<&T> {
if vec.len() > 0 { return Some(&vec[0]); }
None
}
这个函数是拿到一个非空集合的第一个元素。你留意一下参数和返回值类型，可以看到都有引用符号。所以我们期望一个函数在接收数据、吐出数据的时候，如果没有修改发生，就都使用引用类型。你想一想，这样是不是很好？
我们试一下这个函数：
let f: Option<&i32> = first(&vec![1]);
println!("{}", match f {
None => { "none".to_string()}
Some(i) => { (*i).to_string() }
})
是不是应该输出 1 ？
—— Hold on！ 这里有个trick，你运行一下就知道，不能把未命名变量穿进去，因为没命名，函数结束变量会被清理的，后面就没法再用了。
这倒没关系，我们提出变量来：
let vec1 = &vec![3,1,21];
let f: Option<&i32> = first(vec1);
println!("{}", match f {
None => { "none".to_string()}
Some(i) => { (*i).to_string() }
})
果然打印了
3。
我们的需求是拿到集合的第一个元素，并且再给集合添加一个元素。前面就知道，如果我们在拿到元素后处理集合，会引起悬垂引用，rust会禁止编译通过：
存在两处可变引用，而可变引用是唯一引用。这可咋整呀，难道除了克隆没其他办法了吗？
lifetime
当你只是把iPad借给朋友还不够，你还需要问他说会借多久。到期后需要把iPad还给你，毕竟这是你的财产。
rust 中的引用也有这个属性，称为“生存期”（lifetime）。
等一下，我们之前看的资料都说是“生命周期”啊！
的确，我这里理正了一下。lifetime 这个单词，和rust想表达的意思，跟生命周期（life cycle）没有关系，它不表示一个时间的往复或循环，而是表示这个时间是多久。当然”多久“不是说几秒几分钟，而是说具有相同生存期的引用能够存活的时间一样。
生存期也是一个变量，需要跟引用类型搭配，以一个单引号连接一个变量名表示。比如上面的first函数，使用生存期完整写出来为：
fn first<'a, T>(vec: &'a Vec<T>) -> Option<&'a T>
'a 就是生存期变量，表示参数vec 可以被借用多久。返回值也有这个变量，所以返回值和参数拥有相同的生存期。
上面我们没有使用生存期，rust默认也分配了（不用显式写称为“生存期消除”），因为每个引用都必须有生存期。但是默认的生存期不一定合适，编译报错的原因就是生存期不兼容：默认返回值和参数是相同生存期，所以f和vec1 生存期相同，一直到 f 被打印完。如果我们进行push，会再一次引用，并且生存期相同，这样first函数和push方法的生存期就重叠了：first 也是持续到main 函数结束，push也是。
针对这个例子，我们可以先print再push，这样他们的生存期不就不重叠了吗？你试一下看。
在集合求最小值的时候，前面也用到了clone：
现在我们去掉这个克隆，看使用lifetime如何实现。
fn vec_min<T: Minimum>(vec: &Vec<T>) -> SomethingOrNothing<&T> {
let mut min = Nothing;
for e in vec {
min = Something(match min {
Something(i) => { e.compare(i) }
Nothing => { e }
})
}
min
}
现在返回类型的泛型参数是引用类型了，所以Nothing分支的*可以去掉了；而Something分支的里面需要也是引用类型。所以修改Minimum特征的方法为：
pub trait Minimum : Clone {
fn compare(&self, s: &Self) -> &Self;
}
参数和返回类型也都携带了&符号。
可是，如果你现在去相应的修改实现：
impl Minimum for i32 {
fn compare(&self, s:&Self) -> &Self {
if *self < *s { self } else { s }
}
}
或者
impl Minimum for BigInteger {
fn compare<'a>(&'a self, s:&'a Self) -> &'a Self {
debug_assert!(self.test_invariant());
debug_assert!(s.test_invariant());
if self.data.len() < s.data.len() { self } else if self.data.len() > s.data.len() { s } else {
let i = self.data.len();
let mut j = i - 1;
while j >= 0 {
let this_digit = self.data[j];
let other_digit = s.data[j];
if this_digit > other_digit { return s; } else if this_digit < other_digit { return self; } else {
j = j - 1;
}
}
s
}
}
}
从所有权角度看似乎没问题，但是rust会告诉你这两个实现有相同的问题：生存期不匹配
因为默认情况下，两个引用类型参数的生存期并不相同。我们使用克隆的时候，用的是克隆后的新数据，没有生存期的问题。不克隆的时候，使用引用类型就会有这个问题。
所以我们强制两个参数使用同一个生存期变量：
pub trait Minimum {
fn compare<'a>(&'a self, s:&'a Self) -> &'a Self;
}
相应地，实现也加上生存期参数：
impl Minimum for i32 {
fn compare<'a>(&'a self, s:&'a Self) -> &'a Self {
if *self < *s { self } else { s }
}
}
和
impl Minimum for BigInteger {
fn compare<'a>(&'a self, s:&'a Self) -> &'a Self {
debug_assert!(self.test_invariant());
debug_assert!(s.test_invariant());
if self.data.len() < s.data.len() { self } else if self.data.len() > s.data.len() { s } else {
let i = self.data.len();
let mut j = i - 1;
while j >= 0 {
let this_digit = self.data[j];
let other_digit = s.data[j];
if this_digit > other_digit { return s; } else if this_digit < other_digit { return self; } else {
j = j - 1;
}
}
s
}
}
}
只是方法签名上增加了'a，实现的代码一点没变，就可以正常执行了！
继续给BigInteger增加能力。
add
既然是数，那就可以进行相加（我们没处理它的符号，所以就不相减了）。rust 中可以进行操作符重载，加法可以应用在任何类型上。要提供相加的能力，需要实现 Add trait：
use std::ops::Add;
impl Add for BigInteger {
type Output = BigInteger;
fn add(self, rhs: Self) -> Self::Output {
let max_len = cmp::max(self.data.len(), rhs.data.len());
let mut res_vec: Vec<u8> = Vec::with_capacity(max_len + 1);
let mut carry_bit = 0_u8;
for i in 0..max_len {
let left = if i < self.data.len() { self.data[i] } else { 0 };
let right = if i < rhs.data.len() { rhs.data[i] } else { 0 };
let added = left + right + carry_bit;
let bit = added % 10;
carry_bit = if added >= 10 { 1 } else { 0 };
res_vec.push(bit);
}
if carry_bit == 1 { res_vec.push(1) }
BigInteger::from_vec(res_vec)
}
}
逻辑应该比较简单，就是从个位开始按位相加，超过10加进一位；为了防止集合扩容，一开始就把位数加了1。这里额外说两点：
- 加法操作可以应用在两个不同类型的变量上，所以你看
add方法需要指定参数的类型；并且，结果可以是第三个类型，所以需要指定结果的类型 - 结果的类型是一个
Output，你写这段代码的时候能发现，这个类型是从特征里带过来的，函数签名里是固定的Self::Output。它就像Java中的抽象方法，需要实现类去指明。rust 没把它叫做“抽象类型”，而是称为“关联类型” （Associated Types）。
我们测试一下这段代码。
#[test]
我说“测试”是真的测试，不是用main函数去跑一下。
换个函数跑一下，头上增加一个属性#[test]就叫测试函数了。
#[test]
fn add_them() {
let a = BigInteger::from_vec(vec![7, 3, 1]);
let b = BigInteger::from_vec(vec![3, 9, 2, 8]);
let integer = a + b;
println!("{}", integer);
println!("done")
}
用IDE开发一般能直接运行这个测试函数并看到结果；如果是命令行就使用cargo test，但是cargo test只会告诉你测试的结果，不会看到执行的结果，所以看不到print出来的东西。你应该知道测试的结果应该使用断言，所以我们改一下：
#[test]
fn add_them() {
let a = BigInteger::from_vec(vec![7, 3, 1]);
let b = BigInteger::from_vec(vec![3, 9, 2, 8]);
let integer = a + b;
println!("{}", integer);
println!("done");
assert_eq!(integer, BigInteger::from_vec(vec![0, 3, 4, 8]));
assert!(integer == BigInteger::from_vec(vec![0, 3, 4, 8]))
}
一执行就报错，为啥呢？我们只给 BigInteger 增加了相加的能力，没增加相等的能力，不能用==比较。
eq
要允许类型进行双等号比较，需要实现另一个 trait，叫PartialEq：
impl PartialEq for BigInteger {
fn eq(&self, other: &Self) -> bool {
self.data == other.data
}
}
Vec 已经实现了这个trait，所以我们之间判断它们是否相等就可以了。
再运行还报错：
因为assert_eq!这个宏是比较的两个字符串是否相等，所以需要告诉rust如何格式化对象。
这两个宏在打release的时候都会被忽略掉
fmt
rust 中有两个常用 trait 都提供了fmt方法：
- Display，
print!宏会用到这个实现(（注意for-in中的..=）)：
use std::fmt::{Debug, Display, Formatter};
impl Display for BigInteger {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
let mut num = "".to_string();
for index in 1..=self.data.len() {
num.push_str(&(self.data[self.data.len() - index]).to_string());
}
write!(f, "{}", num)
}
}
- Debug，
assert_eq!宏要用到这个实现：
impl Debug for BigInteger {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
self.data.fmt(f)
}
}
现在可以去跑测试函数了。
有时候，我们期望程序的输出更友好，比如这样：
let a = BigInteger::from_vec(vec![7, 3, 1]);
let b = BigInteger::from_vec(vec![3, 9, 2, 8]);
let integer = a + b;
println!("{} + {} = {}", a, b, integer);
我们当然希望它打印1 + 2 = 3这样好看的结果，但实际上你可能已经想到了，rust会编译失败：因为+的时候把两个变量消费掉了。
好吧，再来看看怎么用生存期解决这个问题。
impl<'a,'b> Add<&'a BigInteger> for &'b BigInteger {
type Output = BigInteger;
fn add(self, rhs: &'a BigInteger) -> Self::Output {
let max_len = cmp::max(self.data.len(), rhs.data.len());
let mut res_vec: Vec<u8> = Vec::with_capacity(max_len + 1);
let mut carry_bit = 0_u8;
for i in 0..max_len {
let left = if i < self.data.len() { self.data[i] } else { 0 };
let right = if i < rhs.data.len() { rhs.data[i] } else { 0 };
let added = left + right + carry_bit;
let bit = added % 10;
carry_bit = if added >= 10 { 1 } else { 0 };
res_vec.push(bit);
}
if carry_bit == 1 { res_vec.push(1) }
BigInteger::from_vec(res_vec)
}
}
我们定义了两个生存期变量，给第一个加数赋予'b的生存期，第二个加数赋予'a的生存期。这样我们需要明确Add的泛型参数 —— Add是有泛型参数的，只是默认和第一个加数一样，之前我们没写。现在测试代码改成
let a = &BigInteger::from_vec(vec![7, 3, 1]);
let b = &BigInteger::from_vec(vec![3, 9, 2, 8]);
let integer = a + b;
println!("{} + {} = {}", a, b, integer);
可以正常输出了。
你可能说：不对吧，两个加数没有任何地位上的差异，他俩的生存期本来就是一样的，为啥要使用两个？你可真聪明，其实这里使用一个生存期变量就可以了。所以解决所有权转移的关键是使用引用而非使用生存期。但是为什么这里我们必须加上生存期呢？因为跟函数不同，特征方法的实现必须明确生存期，不可消除或省略。
可能你又疑惑了：为什么之前没有呢？你咋又不聪明了，因为生存期是给引用类型使用的，当你使用
&的时候才会用到。所以这带来一个“劝退”问题：rust的代码总是大量出现&'_这样的写法，太丑了！
