如何在 Rust 中獲取兩個結構以使用並共享對另一個結構的引用

Question

我一直在嘗試使用更復雜的結構，當值包含在另一個結構中時，我在嘗試使用一個結構編輯值時遇到了麻煩。 這樣做的目的是能夠從潛在用戶的角度編寫一個簡單的抽象，這樣他們就只有一個結構，他們必須改變和使用。

示例代碼：

#[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 結構中只使用一次嗎？

Answer 1

您實際上是在通過所有這些實例修改值，這使問題變得更加困難。

---

背景

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

Answer 2

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