堆栈内存溢出
  繁体   English   中英

如何在 Rust 中获取两个结构以使用并共享对另一个结构的引用

[英]How Can I Get Two Structs in Rust to Use and Share a reference to Another Struct

 原文  2022-06-09 18:55:19  3   2    rust

问题描述

我一直在尝试使用更复杂的结构，当值包含在另一个结构中时，我在尝试使用一个结构编辑值时遇到了麻烦。 这样做的目的是能够从潜在用户的角度编写一个简单的抽象，这样他们就只有一个结构，他们必须改变和使用。

示例代码：

#[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>但我不确定是否需要包装存储具有这些类型的小部件的向量和引用它的用户。 我可以在 User 结构中只使用一次吗？

2 个解决方案

解决方案1
 3 已采纳  2022-06-09 19:21:45

您实际上是在通过所有这些实例修改值，这使问题变得更加困难。

背景

rust 中的所有权基础说明了三件事：

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

这也适用于Rc和Arc ，这意味着，虽然它们可以访问多个“所有者”，但它们只是不可变地这样做。

要实际修改这些值，您需要创建内部 mutability 。 这通常在单线程情况下使用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
 0  2022-06-09 19:28:40

使用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);
}

暂无
暂无

声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

相关问题 如何使用 serde 将结构序列化为另一个 Rust 数据结构？ 我如何跟踪 Rust 中的结构实例？ 如何在特征中使用枚举并在枚举中的结构上实现特征？ Rust Rust 中的两个参考变量如何相等？ 如何在 Rust 中的结构中使用循环依赖？ Rust 递归引用另一个结构中的“self” 有两个相互引用的结构 - rust 我使用什么生命周期来创建循环引用彼此的 Rust 结构？ Rust：如何在 Struct::new() 期间从另一个成员创建对结构成员的可变引用？ Rust 如何获取从 Rust 配置箱中的配置文件解析出来的内部嵌套结构
相关标签
 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM