logo标签列表

如何在Rust中让两个结构体使用和共享对另一个结构体的引用？

rust
3

我一直在尝试使用更复杂的结构体，但是当尝试编辑其中一个结构体中包含的值时遇到了麻烦。这样做的目的是从潜在用户的角度编写简单的抽象化代码，让他们只需要处理和更改一个结构体。

示例代码：

#[derive(Debug)]
pub struct Widget {
    counter: u16,
}

impl Widget{
    pub fn new() -> Widget {
        let nw = Widget {
            counter: 0
        };
        return nw;
    }
}

pub struct Market {
    widgets: Vec<Widget>
}

impl Market {
    pub fn new() -> Market {
        let market_vec = Vec::new();
        let market = Market {
            widgets: market_vec
        };
        return market;
    }

    pub fn new_user(&mut self) -> User {
        let user_widget = Widget::new();
        let user = User::new(user_widget);
        self.widgets.push(user_widget);
        return user;
    }
}

pub struct User {
    name: String,
    widget: Widget
}

impl User {
    pub fn new(user_widget: Widget) -> User {
        let user = User {
            name: "User1".to_string(),
            widget: user_widget
        };
        return user;
    }

    pub fn update_count(&mut self) {
        self.widget.counter +=1;
    }
}


pub fn main() {
    let mut market = Market::new();
    let mut user1 = market.new_user();
    println!("{:?}", market.widgets);
    user1.update_count();
    println!("{:?}", market.widgets);
}

例子输出：

  Compiling playground v0.0.1 (/playground)
error[E0382]: use of moved value: `user_widget`
  --> src/main.rs:31:27
   |
29 |         let user_widget = Widget::new();
   |             ----------- move occurs because `user_widget` has type `Widget`, which does not implement the `Copy` trait
30 |         let user = User::new(user_widget);
   |                              ----------- value moved here
31 |         self.widgets.push(user_widget);
   |                           ^^^^^^^^^^^ value used here after move

For more information about this error, try `rustc --explain E0382`.
error: could not compile `playground` due to previous error

在理论上，我想让用户内的小部件成为对小部件的引用，但我无法使用引用来初始化用户，然后修改该引用。我已经尝试过使用 Arc<T> 或 RC<T> ，但我不确定是否需要同时包装存储控件的向量和引用它的用户。我可以只在用户结构中使用一次吗？
Rc 绝对是正确的选择（只有在使用线程时才需要 Arc）。您可能想要查看 Mutex，以便在引用之间启用可变性。 - Jeremy Meadows
是的，引用需要是可变的，这样计数器就可以通过用户进行更新，并且该更改也会反映在市场向量中。 - luvguru69
2个回答
6

在这些实例中，您实际上正在修改值，这使问题变得更加困难。

背景

Rust中所有权的基本原则包括：

  • 每个对象仅由一个所有者拥有
  • 多个不可变引用可以读取对象
  • 仅有一个可变引用可以写入对象。如果存在可变引用，则不能存在任何其他引用（包括不可变引用）。

这也适用于Rc和Arc，这意味着虽然它们提供了对多个“所有者”的访问，但只是以不可变的方式。

要实际修改值，您需要创建内部可变性。在单线程情况下，通常使用RefCell来实现，而在多线程情况下，则使用Mutex。

解决方案＃1

这是带有Rc<RefCell>的代码：

use std::{cell::RefCell, rc::Rc};

#[derive(Debug)]
pub struct Widget {
    counter: u16,
}

impl Widget {
    pub fn new() -> Widget {
        let nw = Widget { counter: 0 };
        return nw;
    }
}

pub struct Market {
    widgets: Vec<Rc<RefCell<Widget>>>,
}

impl Market {
    pub fn new() -> Market {
        let market_vec = Vec::new();
        let market = Market {
            widgets: market_vec,
        };
        return market;
    }

    pub fn new_user(&mut self) -> User {
        let user_widget = Rc::new(RefCell::new(Widget::new()));
        let user = User::new(user_widget.clone());
        self.widgets.push(user_widget);
        return user;
    }
}

pub struct User {
    name: String,
    widget: Rc<RefCell<Widget>>,
}

impl User {
    pub fn new(user_widget: Rc<RefCell<Widget>>) -> User {
        let user = User {
            name: "User1".to_string(),
            widget: user_widget,
        };
        return user;
    }

    pub fn update_count(&mut self) {
        self.widget.borrow_mut().counter += 1;
    }
}

pub fn main() {
    let mut market = Market::new();
    println!("{:?}", market.widgets);
    let mut user1 = market.new_user();
    user1.update_count();
    println!("{:?}", market.widgets);
}


[]
[RefCell { value: Widget { counter: 1 } }]

解决方案 #2

在您的特定情况下，我注意到您实际上只更新了计数器 counter。

因此，您实际上不需要使整个Widget可变，而是可以只使计数器可变。 计数器比Widget类更简单，因此我们可以对其进行优化。

在单线程情况下，我们可以使用Cell。Cell与RefCell相同，但不会失败。但是，Cell仅存在于复制对象中。

在多线程情况下，我们可以使用AtomicU16。 它比Mutex要效率高得多； 实际上，在大多数情况下，与普通的u16相比，它的开销是零。

以下是使用Cell<u16>的解决方案：

use std::{cell::Cell, rc::Rc};

#[derive(Debug)]
pub struct Widget {
    counter: Cell<u16>,
}

impl Widget {
    pub fn new() -> Widget {
        let nw = Widget { counter: 0.into() };
        return nw;
    }
}

pub struct Market {
    widgets: Vec<Rc<Widget>>,
}

impl Market {
    pub fn new() -> Market {
        let market_vec = Vec::new();
        let market = Market {
            widgets: market_vec,
        };
        return market;
    }

    pub fn new_user(&mut self) -> User {
        let user_widget = Rc::new(Widget::new());
        let user = User::new(user_widget.clone());
        self.widgets.push(user_widget);
        return user;
    }
}

pub struct User {
    name: String,
    widget: Rc<Widget>,
}

impl User {
    pub fn new(user_widget: Rc<Widget>) -> User {
        let user = User {
            name: "User1".to_string(),
            widget: user_widget,
        };
        return user;
    }

    pub fn update_count(&mut self) {
        let prev = self.widget.counter.get();
        self.widget.counter.set(prev + 1);
    }
}

pub fn main() {
    let mut market = Market::new();
    println!("{:?}", market.widgets);
    let mut user1 = market.new_user();
    user1.update_count();
    println!("{:?}", market.widgets);
}


[]
[Widget { counter: Cell { value: 1 } }]

线程安全版本

为了完整起见，在多线程环境下，这里提供相同的解决方案。

使用 Arc<Mutex>：

use std::sync::{Arc, Mutex};

#[derive(Debug)]
pub struct Widget {
    counter: u16,
}

impl Widget {
    pub fn new() -> Widget {
        let nw = Widget { counter: 0 };
        return nw;
    }
}

pub struct Market {
    widgets: Vec<Arc<Mutex<Widget>>>,
}

impl Market {
    pub fn new() -> Market {
        let market_vec = Vec::new();
        let market = Market {
            widgets: market_vec,
        };
        return market;
    }

    pub fn new_user(&mut self) -> User {
        let user_widget = Arc::new(Mutex::new(Widget::new()));
        let user = User::new(user_widget.clone());
        self.widgets.push(user_widget);
        return user;
    }
}

pub struct User {
    name: String,
    widget: Arc<Mutex<Widget>>,
}

impl User {
    pub fn new(user_widget: Arc<Mutex<Widget>>) -> User {
        let user = User {
            name: "User1".to_string(),
            widget: user_widget,
        };
        return user;
    }

    pub fn update_count(&mut self) {
        self.widget.lock().unwrap().counter += 1;
    }
}

pub fn main() {
    let mut market = Market::new();
    println!("{:?}", market.widgets);
    let mut user1 = market.new_user();
    user1.update_count();
    println!("{:?}", market.widgets);
}


[]
[Mutex { data: Widget { counter: 1 }, poisoned: false, .. }]

使用 AtomicU16:

use std::{
    sync::atomic::{AtomicU16, Ordering},
    sync::Arc,
};

#[derive(Debug)]
pub struct Widget {
    counter: AtomicU16,
}

impl Widget {
    pub fn new() -> Widget {
        let nw = Widget { counter: 0.into() };
        return nw;
    }
}

pub struct Market {
    widgets: Vec<Arc<Widget>>,
}

impl Market {
    pub fn new() -> Market {
        let market_vec = Vec::new();
        let market = Market {
            widgets: market_vec,
        };
        return market;
    }

    pub fn new_user(&mut self) -> User {
        let user_widget = Arc::new(Widget::new());
        let user = User::new(user_widget.clone());
        self.widgets.push(user_widget);
        return user;
    }
}

pub struct User {
    name: String,
    widget: Arc<Widget>,
}

impl User {
    pub fn new(user_widget: Arc<Widget>) -> User {
        let user = User {
            name: "User1".to_string(),
            widget: user_widget,
        };
        return user;
    }

    pub fn update_count(&mut self) {
        self.widget.counter.fetch_add(1, Ordering::SeqCst);
    }
}

pub fn main() {
    let mut market = Market::new();
    println!("{:?}", market.widgets);
    let mut user1 = market.new_user();
    user1.update_count();
    println!("{:?}", market.widgets);
}


[]
[Widget { counter: 1 }]
解决方案#2是我一直在寻找的。感谢您包含它。 - luvguru69
现在也添加了多线程版本。很高兴我能帮到你。 - Finomnis
我总是忘记 std 中有 Atomic 类型，您知道它们的占用空间是否比 Mutex 更小吗？ 我想这可能取决于硬件是否支持原子指令... - Jeremy Meadows
1
巨大的小占地面积。例如，在x86中，对于u32的所有读/写操作已经是原子性的。AtomicU32主要只是一个空包装器，用于通知编译器关于可变性的信息。 - Finomnis
1
@JeremyMeadows 只是为了说明：AtomicU32 vs Mutex<U32>。差别之大真是令人难以置信。而且这还是使用-C opt-level=3编译的结果。 - Finomnis
1
哇，这个差别比我预想的大多了，虽然 mov 是原子操作这一点也说得通。谢谢你提供的例子 :) - Jeremy Meadows
-1
使用Rc和Mutex，您可以将每个Widget包装起来，以便您传递对该单独结构的可变引用。
我也稍微修改了您的代码，这样对我来说更容易工作，希望它仍然非常易读。
use std::rc::Rc;
use std::sync::Mutex;

#[derive(Debug)]
pub struct Widget {
    counter: u16,
}

impl Widget {
    pub fn new() -> Widget {
        Widget { counter: 0 }
    }
}

type MutWidget = Rc<Mutex<Widget>>;

pub struct Market {
    widgets: Vec<MutWidget>,
}

impl Market {
    pub fn new() -> Market {
        Market {
            widgets: Vec::new(),
        }
    }

    pub fn new_user(&mut self) -> User {
        let user_widget = Rc::new(Mutex::new(Widget::new()));
        
        let user = User::new(user_widget.clone());
        self.widgets.push(user_widget.clone());
        return user;
    }
}

pub struct User {
    name: String,
    widget: MutWidget,
}

impl User {
    pub fn new(user_widget: MutWidget) -> User {
        User {
            name: "User1".to_string(),
            widget: user_widget,
        }
    }

    pub fn update_count(&mut self) {
        self.widget.lock().unwrap().counter += 1;
    }
}

pub fn main() {
    let mut market = Market::new();
    println!("{:?}", market.widgets);
    
    let mut user1 = market.new_user();
    user1.update_count();
    
    println!("{:?}", market.widgets);
}
1
嘿 :) 我认为 Rc<Mutex> 的组合并没有太多意义。Mutex 用于线程安全，因此您需要使用 Arc 而不是 Rc。在单线程情况下，RefCell 比 Mutex 更高效。 - Finomnis
肯定的是，我几乎从未需要过“单元格(Cell)”，直到看了你的回答才想起它们的存在哈哈。 - Jeremy Meadows
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接