我一直在尝试使用更复杂的结构,当值包含在另一个结构中时,我在尝试使用一个结构编辑值时遇到了麻烦。这样做的目的是能够从潜在用户的角度编写一个简单的抽象,这样他们就只有一个结构,他们必须改变和使用。
示例代码:
#[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 结构中只使用一次吗?
您实际上是在通过所有这些实例修改值,这使问题变得更加困难。
rust 中的所有权基础说明了三件事:
这也适用于Rc
and Arc
,意思是,虽然它们向多个“所有者”提供访问权限,但它们只是不可变地这样做。
要实际修改这些值,您需要创建内部 mutability。这通常RefCell
在单线程情况下完成,或者Mutex
在多线程情况下完成。
这是您的代码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 } }]
在您的具体情况下,我注意到您实际更新的唯一内容是counter
.
因此,您实际上不需要使整个Widget
可变,而是可以只使计数器可变。计数器比Widget
类更简单,因此我们可以对其进行一些优化。
在单线程情况下,我们可以使用Cell
. Cell
与 相同RefCell
,但不能失败。但Cell
只存在于可复制对象。
在多线程的情况下,我们可以使用AtomicU16
. 它比 a 效率高得多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 }]
本文收集自互联网,转载请注明来源。
如有侵权,请联系 [email protected] 删除。
我来说两句