1

我的心态是让我String的 s 保持不变，一个单一的事实来源。当我将同样的心态带入 Rust 时，我发现我必须做很多克隆。由于Strings 没有改变，所有的克隆都是不必要的。下面有一个例子和相关游乐场的链接。

借用似乎不是一种选择，因为我必须处理引用及其生命周期。我的下一个想法是使用类似Rc或Cow结构的东西。但是用类似的东西包裹所有的StringsRc感觉不自然。在我有限的 Rust 经验中，我从未见过任何暴露的所有权/内存管理结构，即Rcand Cow. 我很好奇一个更有经验的 Rust 开发人员会如何处理这样的问题。

Rc在 Rust 中公开所有权/内存管理结构，比如and是否真的很自然Cow？我应该使用切片吗？

use std::collections::HashSet;

#[derive(Debug)]
enum Check {
    Known(String),
    Duplicate(String),
    Missing(String),
    Unknown(String)
}

fn main() {
    let known_values: HashSet<_> = [
        "a".to_string(),
        "b".to_string(),
        "c".to_string()]
            .iter().cloned().collect();

    let provided_values = vec![
        "a".to_string(),
        "b".to_string(),
        "z".to_string(),
        "b".to_string()
    ];

    let mut found = HashSet::new();

    let mut check_values: Vec<_> = provided_values.iter().cloned()
        .map(|v| {
            if known_values.contains(&v) {
                if found.contains(&v) {
                    Check::Duplicate(v)
                } else {
                    found.insert(v.clone());
                    Check::Known(v)
                }
            } else {
                Check::Unknown(v)
            }
        }).collect();

    let missing = known_values.difference(&found);

    check_values = missing
        .cloned()
        .fold(check_values, |mut cv, m| {
            cv.push(Check::Missing(m));
            cv
        });

    println!("check_values: {:#?}", check_values);
}
4

1 回答 1

0

从我的问题评论中的讨论来看，String示例中所有不可变的克隆都是正确的。由于 Rust 通过所有权而不是其他语言的引用来处理内存，因此克隆是必要的。

充其量，不使用Rc，我可以通过使用移动语义 on 来减少克隆provided_values。

更新：一些有趣的阅读

Cow在我的示例中不起作用，因为它涉及借用参考。Rc将是我必须使用的。在我的示例中，所有内容都必须转换为，Rc但我可以看到这一切都可以通过封装隐藏起来。


use std::collections::HashSet;
use std::rc::Rc;

#[derive(Debug)]
enum Check {
    Known(Rc<String>),
    Duplicate(Rc<String>),
    Missing(Rc<String>),
    Unknown(Rc<String>)
}

fn main() {
    let known_values: HashSet<_> = [
        Rc::new("a".to_string()),
        Rc::new("b".to_string()),
        Rc::new("c".to_string())]
            .iter().cloned().collect();

    let provided_values = vec![
        Rc::new("a".to_string()),
        Rc::new("b".to_string()),
        Rc::new("z".to_string()),
        Rc::new("b".to_string())
    ];

    let mut found = HashSet::new();

    let mut check_values: Vec<_> = provided_values.iter().cloned()
        .map(|v| {
            if known_values.contains(&v) {
                if found.contains(&v) {
                    Check::Duplicate(v)
                } else {
                    found.insert(v.clone());
                    Check::Known(v)
                }
            } else {
                Check::Unknown(v)
            }
        }).collect();

    let missing = known_values.difference(&found);

    check_values = missing
        .cloned()
        .fold(check_values, |mut cv, m| {
            cv.push(Check::Missing(m));
            cv
        });

    println!("check_values: {:#?}", check_values);
}

操场

于 2020-03-15T17:05:52.900 回答