rust漫游 - 写时拷贝 Cow<'_, B>

rust漫游 - 写时拷贝 Cow<'_, B>

Cow 是一个写时复制功能的智能指针，在数据需要修改或者所有权发生变化时使用，多用于读多写少的场景。

pub enum Cow<'a, B: ?Sized + 'a>
where
    B: ToOwned,
{
    /// Borrowed data.
    Borrowed(&'a B),

    /// Owned data.
    Owned(<B as ToOwned>::Owned),
}

数据在写入的情况下 Cow 才有存在的意义。当借用的数据被修改时，在不破坏原有数据的情况下，克隆一个副本并且在副本上进行修改；这是一种惰性的策略，在真正需要修改时才产生克隆的操作，而并不预先克隆。

关键函数

• to_mut(), 获取所有权数据的可变引用，无所有权时从借用数据中克隆
• into_owned(), 提取所有权数据。

使用

官方示例

官方描述了三种情况

1. 借用数据，但是未调用 to_mut()，故不存在 clone 操作
2. 借用数据，调用 to_mut(), 发生 clone 操作
3. 所有权数据，调用 to_mut(), 不存在 clone 操作，因为具有该数据的所有权

use std::borrow::Cow;

fn abs_all(input: &mut Cow<[i32]>) {
    for i in 0..input.len() {
        let v = input[i];
        if v < 0 {
            // Clones into a vector if not already owned.
            input.to_mut()[i] = -v;
        }
    }
}

// No clone occurs because `input` doesn't need to be mutated.
let slice = [0, 1, 2];
let mut input = Cow::from(&slice[..]);
abs_all(&mut input);

// Clone occurs because `input` needs to be mutated.
let slice = [-1, 0, 1];
let mut input = Cow::from(&slice[..]);
abs_all(&mut input);

// No clone occurs because `input` is already owned.
let mut input = Cow::from(vec![-1, 0, 1]);
abs_all(&mut input);

观察所有权的变化

写了个地址打印函数，以此来观察所有权的变化。

fn print_addr(s: &str) {
    println!("{}", s);
    let mut p = s.as_ptr();
    for ch in s.chars() {
        println!("\t{:p}\t{}", p, ch);
        p = p.wrapping_add(ch.len_utf8());
    }
}

借用修改取出所有权

对借用的数据进行修改操作（有可能不会修改，见下文），操作完成后取出所有权 是最常见的用法

以下是一般的借用数据从修改至获取所有权数据的过程，通过新产生的地址可以看出来存在 clone 操作

{
    let s = String::from("AB");
    print_addr(&s);
    let mut cow = Cow::Borrowed(&s);
    cow.to_mut().insert_str(1, "cd");
    let sr = cow.into_owned();
    print_addr(&sr);
}

// AB
//         0x7fb694c05af0  A
//         0x7fb694c05af1  B
// AcdB
//         0x7fb694c05b00  A
//         0x7fb694c05b01  c
//         0x7fb694c05b02  d
//         0x7fb694c05b03  B

上面的代码注释 to_mut() 行后，相当于不会有获取所有权的需求，这个时候是不应该做修改的，into_owned() 应该弃用转而使用 as_str() 这类没有所有权变化的操作.

{
    let s = String::from("AB");
    print_addr(&s);
    let mut cow = Cow::Borrowed(&s);
    // cow.to_mut().insert_str(1, "cd"); // 这一行是运行时决定的
    let sr = cow.as_str(); // 看后续的使用，若是后续也只是读操作可以使用 as_str()
    print_addr(&sr);
}

在所有权数据上进行修改

在对已具有所有权数据上操作时，字符串的地址未发生改变，未发生 clone 操作

insert_str 为两个 memcpy 操作，故首地址不会发生变化

{
    let s1 = String::from("cd");
    print_addr(&s1);
    let mut cow1: Cow<'_, String> = Cow::Owned(s1);
    cow1.to_mut().insert_str(0, "AB");
    let sr1 = cow1.into_owned();
    print_addr(&sr1);
}

// cd
//         0x7fb694c05b10  c
//         0x7fb694c05b11  d
// ABcd
//         0x7fb694c05b10  A
//         0x7fb694c05b11  B
//         0x7fb694c05b12  c
//         0x7fb694c05b13  d

实现

Cow 是一个枚举值，包含了一个借用和所有。可以使用 Cow 的类型需要实现了 ToOwned trait。

ToOwned trait 同样包含了所有权或借用的操作。

1. 需要实现 Borrow 借用 trait
2. 可以从借用的数据中创建所有权数据或者克隆

相关 trait

pub trait ToOwned {
    type Owned: Borrow<Self>;  // 需要实现 Borrow triat

    pub fn to_owned(&self) -> Self::Owned;  // 所有权创建
    pub fn clone_into(&self, target: &mut Self::Owned) { ... }
}

pub trait Borrow<Borrowed> where
    Borrowed: ?Sized, {
    pub fn borrow(&self) -> &Borrowed;
}

Borrow 借用 triat 泛型实现

impl<T: ?Sized> Borrow<T> for T {
    fn borrow(&self) -> &T {
        self
    }
}

to_owned 创建所有权的泛型实现如下，取决该类型是否实现 Clone tait

impl<T> ToOwned for T
where
    T: Clone,
{
    type Owned = T;
    fn to_owned(&self) -> T {
        self.clone()
    }
}

方法

to_mut()

获取所有权的可变引用

1. 已获取所有权直接返回引用
2. 借用数据的情况先调用 to_owned() 获取克隆副本的所有权，并且做一个检查

ref 关键字指示模式匹配为借用而不是移动。

<B as ToOwned>::Owned 表示 B 类型实现了 ToOwned trait，现使用该 trait 中的 Owned 类型，本质就是B类型本身，但是限制了实现 trait

pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned {
    match *self {
        Borrowed(borrowed) => {
            *self = Owned(borrowed.to_owned());
            match *self {
                Borrowed(..) => unreachable!(),
                Owned(ref mut owned) => owned,
            }
        }
        Owned(ref mut owned) => owned,
    }
}

into_owned()

取出 Cow 中的所有权数据，当为获取所有权时，进行 clone 操作

pub fn into_owned(self) -> <B as ToOwned>::Owned {
    match self {
        Borrowed(borrowed) => borrowed.to_owned(),
        Owned(owned) => owned,
    }
}

deref

由于 Cow 也实现了 Deref trait, 支持解引用强制多态，实现如下。

impl<B: ?Sized + ToOwned> Deref for Cow<'_, B> {
    type Target = B;

    fn deref(&self) -> &B {
        match *self {
            Borrowed(borrowed) => borrowed,
            Owned(ref owned) => owned.borrow(),
        }
    }
}

上面代码的 print_addr 的参数既可以是 &str, 也可以为 &Cow.

参考

官方文档