个人中心
gpt4 book ai didi

rust - 如何让 Rust 中的两个结构体使用并共享对另一个结构体的引用

转载 作者：行者123 更新时间：2023-12-05 02:28:39 26 4
gpt4 key购买 nike

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

示例代码:

#[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

理论上我希望 user 中的小部件是对小部件的引用，但我无法使用引用初始化 user 然后修改该引用。我研究过尝试使用 Arc<T>或 RC<T>但我不确定我是否需要包装存储这些类型的小部件的矢量和引用它的用户。我可以在 User 结构中只使用一次吗？

最佳答案

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

背景

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 }]

关于rust - 如何让 Rust 中的两个结构体使用并共享对另一个结构体的引用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/72565306/

26 4 0
文章推荐： sql - 按日期分区一段时间 SQL BigQuery
文章推荐： scheme - 方案延续定义中的一个棘手问题
文章推荐： f# - FsCheck:覆盖类型的生成器，但仅在单个父生成器的上下文中
文章推荐： javascript - 如何调用函数 onclick，同时还更改函数外部文本的值
行者123
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com