Rust的Cow类型有什么用？详解Cow及其用途

Rust的智能指针有哪些？大多数人都能马上答出Box<T>、Rc<T>和Arc<T>、Ref<T>和在异步编程中很常见的Pin<P>等等。不过，有一个可能经常被大多数人遗忘的类型，它功能强大，利用好了可以节省很多复制开销；它就是这篇文章的主角：Cow<B>。

什么是COW（Copy-On-Write）？

在开始之前，有必要先介绍一下COW（Copy-On-Write，写时复制）的概念。COW是一种用于资源管理的优化策略，在操作系统中应用非常广泛。COW的核心思想是当多个任务需要读取同一个资源（比如内存中的数据、文件）的时候，它们会共享同一份资源副本，而不是为每个任务复制一份资源副本。只有当某个任务需要修改这个资源时，才会为这个任务创建一份资源副本。

需要注意的是，上述的整个过程对任务（也就是程序员编写的用户程序）来说都是不可见的；对程序员来说，他并不知道他所使用的资源在发生写操作时才被真正地复制了一份，自始至终他仿佛就像在独占整份资源一样。

COW在文件系统、虚拟内存管理中都有非常成熟的应用；在编程语言中，也被广泛应用于优化字符串、集合的处理。

Cow：定义

Rust的Cow<B>是一个枚举类型，包含两个成员：Borrowed和Owned。不过，我们几乎不会直接用到它的成员，因为Cow<B>实现了Deref特征，这使得我们可以通过Deref转换这一语法糖来便捷地直接使用Cow<B>中的内容。有关Deref转换可以阅读我之前的文章。

pub enum Cow<'a, B>
where
    B: 'a + ToOwned + ?Sized,
{
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}

需要注意一下Cow的模板参数。Cow接受一个生命周期和一个类型B，其中类型B需要实现ToOwned特征；ToOwned特征的介绍可以看之前的文章，这里仅仅提一下所有实现了Clone的类型都会自动实现ToOwned自身。除此以外，成员Owned的内容类型不是类型B本身，而是类型B的ToOwned的目标类型（例如对str来说，这个类型是String）。

使用方法

这里是一段Cow<B>的简单使用范例：

use std::borrow::Cow;

fn main() {
    let foo = "Hello World";
    let mut bar: Cow<str> = Cow::from(foo);
    println!("{bar}");      // 这里没有发生复制
    
    bar.to_mut().push_str(" Rust");  // 这里发生了复制
    println!("{bar}");
    
    println!("{foo}");      // 原来的字符串foo仍然可用，而且没有变化
}

Cow的构造

Cow<B>是一个枚举，所以首先它是可以直接从它的成员Borrowed和Owned来构造的：

use std::borrow::Cow;

fn main() {
    let str_ = "Hello World";
    let string = String::from("Hello World!");
    
    let foo: Cow<str> = Cow::Borrowed(str_);
    let bar: Cow<str> = Cow::Owned(string);
    
    // 这里string不再可用
    // println!("{string}");
}

除此以外，标准库中的五对实现了ToOwned的类型（str/String，[T]/Vec<T>，CStr/CString，OsStr/OsString，Path/PathBuf）也可以使用From::from来构造Cow<B>：

use std::borrow::Cow;

fn main() {
    let str_ = "Hello World";
    let string = String::from("Hello World!");
    
    let foo: Cow<str> = Cow::from(str_);	// from -> Borrowed
    let bar: Cow<str> = Cow::from(string);	// from -> Owned
    
    // 这里string不再可用
    // println!("{string}");
}

使用From::from时，Rust会自动为我们匹配正确的类型（&'a str/String等），一般情况下推荐使用from来构造Cow，而不是手动指定Borrowed/Owned。

deref和to_mut

前面提到过，Cow<B>实现了Deref<B>特征，这意味着我们不需要做任何操作就可以享受Deref转换的语法糖：

use std::borrow::Cow;

fn main() {
    let str1 = "Hello World";
    let cow: Cow<str> = Cow::from(str1);
    let str2: &str = &cow;  // 注意看，我们把&Cow<str>赋给了&str
    
    println!("{str2}"); // Hello World
    println!("{cow}");  // Hello World
    println!("{str1}"); // Hello World
}

use std::borrow::Cow;

fn main() {
    let str1 = "Hello World";
    let cow: Cow<str> = Cow::from(str1);
    
    cow.split(" ").for_each(|s|println!("{s}"));	// 使用str的方法split也不在话下
}

不过，Cow<B>并没有实现DerefMut；这意味着我们对Cow的修改不会影响到底层的内容，相反地，当我们试图修改Cow时，Cow会生成一个副本，并且修改这个拥有所有权的副本：

use std::borrow::Cow;

fn main() {
    let str1 = "Hello";
    let mut cow: Cow<str> = Cow::from(str1);
    
    cow += " World";
    
    println!("cow = {cow}");	// cow = Hello World
    println!("str1 = {str1}");	// str1 = Hello 
}

我们可以多加一点输出代码，来看看具体发生了什么：

#![feature(cow_is_borrowed)]
use std::borrow::Cow;

fn main() {
    let str1 = "Hello";
    let mut cow: Cow<str> = Cow::from(str1);
    
    println!("cow = {cow}, borrowed = {}", cow.is_borrowed());	// cow = Hello, borrowed = true
    
    cow += " World";
    
    println!("cow = {cow}, borrowed = {}", cow.is_borrowed());	// cow = Hello World, borrowed = false
    println!("str1 = {str1}");									// str1 = Hello
}

修改了cow变量后，它不再处于借用状态，而是拥有了这段字符串的所有权——这也是它能够安全地修改这段字符串的关键。

除了直接对Cow<str>使用str中实现的方法来修改字符串之外，还可以使用to_mut()来获取&String来使用String中实现的方法来修改字符串：

use std::borrow::Cow;

fn main() {
    let str1 = "Hello";
    let mut cow: Cow<str> = Cow::from(str1);
    
    cow.to_mut().push_str(" World");
    
    println!("cow = {cow}");	// cow = Hello World
    println!("str1 = {str1}");	// str1 = Hello 
}

再重复一遍：使用to_mut()修改和直接修改Cow<B>的不同在于，to_mut()返回的是&mut <B as ToOwned>::Owned（例如String），可以使用B的Owned类型（例如String）中额外实现的方法（例如String::push_str）；修改Cow<B>的时候，只能使用B中实现的方法（例如上面的+=，也就是str::add_assign）。

消费Cow

在不再需要使用Cow，或者想要完整取得Cow中的对象的所有权的时候，我们可以使用Cow::into_owned方法来消费掉Cow。方法返回的是B的Owned类型（例如String）。

use std::borrow::Cow;

fn main() {
    let str1 = "Hello";
    let mut cow: Cow<str> = Cow::from(str1);
    
    cow.to_mut().push_str(" World");
    
    let owned: String = cow.into_owned();
    
    println!("{owned}");    // Hello World
    println!("{str1}");	    // Hello 
}

在消费掉Cow之后，Cow将不再可用，但它之前借用的原数据不受影响。

用途

说了这么多，Cow到底有什么用呢？少复制几次数据真的那么重要吗？让我们看看标准库中的String::from_utf8_lossy方法吧。

String::from_utf8_lossy是一个把一个字节切片（&[u8]）按照UTF-8转换成&str的方法，并且会用“�”字符来替换掉字节切片中UTF-8不支持的字符。举个例子：

// 不包含错误字节的情况
fn main() {
    let hello = vec![72, 69, 76, 76, 79];
    let hello = String::from_utf8_lossy(&hello);
    assert_eq!("HELLO", hello);
}

以及：

// 包含错误字节的情况
fn main() {
    let input = b"Hello \xF0\x90\x80World";
    let output = String::from_utf8_lossy(input);
    assert_eq!("Hello �World", output);
}

现在假设我们是Rust标准库API的设计师，我们要为from_utf8_lossy方法选择一个恰当的返回类型。

返回&str可以吗？

最直接的想法就是返回一个&str，就像这样：

fn from_utf8_lossy<'a>(v: &'a [u8]) -> &'a str {
   todo!()
}

这种方案可以吗？仔细想想，当字节切片中有UTF-8中不支持的错误字符时，错误字符需要被替换成“�”；直接返回&str的话是做不了对字符串内容的修改的。

返回String呢？

顺着刚才的思路，因为我们可能需要修改字符串，所以我们就需要返回&str的栈上类型String，合情合理：

fn from_utf8_lossy(v: &[u8]) -> String {
   todo!()
}

不过，另一个问题冒出来了：虽然返回String完美地解决了修改字符串之后会导致新字符串无处存放的问题，但是如果旧的字符串（字节切片）不需要修改的话，也需要被复制到String中，这无形中增加了很多不必要的消耗；而且，字节切片中有错误字符是概率很小的事件，为了小概率事件影响拖累大概率发生的正常情况的性能，这值得吗？

这时，我一拍大腿：在需要修改时返回String，不需要修改时返回&str不就好了？

返回(Option<&str>, Option<String>)（或者Either<&str, String>）

这样，上面所描述的性能和功能矛盾就解决了：

fn from_utf8_lossy<'a>(v: &'a [u8]) -> (Option<&'a str>, Option<String>) {
   todo!()
}

但这种解决方式也不是没问题的：太复杂了……而且需要用户判断返回的是&str还是String。不过，这个要么返回借用的&str、要么返回有所有权的String的东西，是不是感觉有点眼熟？

这不就是Cow<str>嘛！

最终方案：返回Cow<str>

经过一番艰难而复杂的思考，我们最终得到了最恰当的结果：

fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str> {
    todo!()
}

使用了Cow<str>之后，它不仅可以在需要修改字符串时克隆并返回新数据，更可以在绝大多数普通情况之下直接借用数据；更妙的是，它可以享受Deref转换的语法糖，可谓十分完美！

总结

Cow是Rust中非常有用的一个类型，虽然日常开发中几乎用不到它，但是某些性能敏感的场景下善用Cow说不定会有奇效喔~