所以,我使用boost :: shared_ptr来提供它提供的所有各种引用计数的好处 - 显然是对启动器的引用计数,还有复制,分配和存储在STL容器中的能力.
问题是,如果我将它传递给一个"恶意"函数或对象,该对象可以保存ptr,然后我将永远无法在没有外部函数或对象很好地放弃其所有权的情况下解除分配它.
最终,我试图保持对象所有权的明确.我通过让所有者将唯一的shared_ptr保留到对象来完成此操作,而"guest"对象仅将weak_ptrs存储到对象.
我真的不想要shared_ptr的"共享"部分,但我需要使用shared_ptr才能生成weak_ptrs.我想使用scoped_ptr,但它非常有限,因为你无法复制它.您无法将其存储在容器中,也无法从中借出weak_ptrs,也无法将所有权转移给新经理.
解决方案是什么？
编译以下使用运算符重载的Rust代码
use std::ops::{Add};
#[derive(Show)]
struct Point {
x: int,
y: int
}
impl Add for Point {
type Output = Point;
fn add(self, other: Point) -> Point {
Point {x: self.x + other.x, y: self.y + other.y}
}
}
fn main() {
let p: Point = Point {x: 1, y: 0};
let pp = p + p;
}
由于p的所有权导致编译器错误:
<anon>:21:18: 21:19 error: use of moved value: `p`
<anon>:21 let pp = p + p;
^
<anon>:21:14: 21:15 note: `p` moved …我正在尝试编写通用的递归数据结构.事实证明,当我想要访问一个拥有的struct值的多个字段时,我无法进入墙.
我定义了一个包含列表的结构:
struct ListNode<T> {
val: T,
tail: List<T>
}
struct List<T>(Option<Box<ListNode<T>>>);
空列表由List(None).表示.
我希望能够附加到列表中:
impl<T> List<T> {
fn append(self, val: T) -> List<T> {
match self {
List(None) => List(Some(Box::new(ListNode {
val: val,
tail: List(None),
}))),
List(Some(node)) => List(Some(Box::new(ListNode {
val: node.val,
tail: node.tail.append(val),
}))),
}
}
}
这失败了一个可以理解的错误:
error[E0382]: use of moved value: `node`
--> src/main.rs:17:23
|
16 | val: node.val,
| -------- value moved here
17 | tail: node.tail.append(val),
| ^^^^^^^^^ value used here after move …我正在学习Rust,我遇到了一些令人困惑的行为.以下代码编译正常并按预期工作(编辑:添加除测试函数以外的代码,之前省略):
struct Container<'a> {
contents : &'a mut i32,
}
fn main() {
let mut one = Container { contents: &mut 5 };
test(&mut one);
println!("Contents: {}",one.contents);
}
fn test<'a>(mut x : &'a mut Container) {
*x.contents += 1;
let y = x;
*y.contents += 1;
x = y;
println!("{:?}",*x.contents)
}
现在在声明中
let y = x;
推断出类型.因为x是类型&'a mut Container,我认为这是等价的:
let y: &'a mut Container = x;
但是当我这样做时,编译器会遇到问题:
test_3.rs:25:5: 25:10 error: cannot assign to `x` …当使用HashMap的get方法时,我得到了一个Option<&T>,这次我再次遇到它Option<&String>.我想获得自有价值Option<String>.没有我写作,这可能map(|x| x.to_owned())吗？
我只是想知道是否有办法为任何实用程序特征编写一个实现该实现的毯子实现？
这是我在 Rust 中的第一个项目，我认为我错过了一些简单的东西。
我正在尝试创建一个简单的 Web API 守护程序，它将接收 JSON 的 POST、解析 JSON，并使用配置文件中提供的凭据发送电子邮件。90% 的问题都很简单。我正在努力解决“在运行时解析配置文件”的问题。
我成功地使用 hyper 和 letter 接收 JSON 并发送电子邮件。但我希望这个守护进程可以在服务器上配置，而不是在构建时配置（像大多数 Linux / Unix 守护进程一样）。我一直孜孜不倦地走过这里。
我创建了一个配置模块，声明了一个结构，并用于lazy_static!{}存储配置结构的初始版本。
我想我已经将问题归结为一个核心问题：如何读取和解析配置文件，然后将值克隆到我的结构中？特别是考虑到这些值的大小在运行时无法得知......
例如src/config.rs
use std::sync::RwLock;
use serde::Deserialize;
use std::fs;
use std::io::prelude::*;
#[derive(Debug, Deserialize, Clone, Copy)]
pub struct RimfireCfg {
pub verbose: u8,
/* web api server config */
pub listen_address: &'static str,
/* mail server config */
pub mailserver: &'static str,
pub port: u16,
pub user: &'static str,
pub password: …我经常遇到一种情况，当我有复杂的类（例如，实现一些数值算法，如偏微分方程求解器）和数据数组时，它可以根据用例拥有或从外部上下文绑定。问题是如何为这样的类制作健壮的析构函数。简单的方法是制作布尔标志，指示是否拥有该数组。例如
// simplest example I can think about
class Solver{
int nParticles;
bool own_position;
bool own_velocity;
double* position;
double* velocity;
// there is more buffers like this, not just position and velocity, but e.g. mass, force, pressure etc. each of which can be either owned or binded externally independently of each other, therefore if there is 6 buffers, there is 2^6 variants of owership (e.g. of construction/destruction)
void move(double dt){ for(int i=0; i<n; i++){ position[i]+=velocity[i]*dt; } }
~Solver(){ …fn main() {
let strA = "a";
let result;
{
let strB = "abc";
result = longest(strA, strB); // Will return strB
}
println!("The longest string is {}", result); // result now point to strB!!
}
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
'a将得到的混凝土的寿命等于该较小的寿命的x和y
那么为什么strB现在在其范围之外可见？
我发现它令人困惑&(*&a)并且&{*&a}行为不同。
详细地说，以下代码编译失败：
struct CanNotCopy;
fn main(){
let a = CanNotCopy;
&{*&a};
let c = a;
}
并编译了以下代码：
struct CanNotCopy;
fn main(){
let a = CanNotCopy;
&(*&a); // or &*&a;
let c = a;
}
上述代码之间的语义区别是什么？
究竟哪些语言结构会导致所有权的转移？
我有一个结构，我想按值获取、变异然后返回。我还想改变它的泛型类型，因为我使用此状态静态地确保函数调用的正确顺序，以实现安全的 FFI（游乐场）：
use core::marker::PhantomData;
struct State1 {}
struct State2 {}
struct Whatever {}
struct X<State> {
a: Whatever,
b: Whatever,
c: Whatever,
_d: PhantomData<State>,
}
impl<State> Drop for X<State> {
fn drop(&mut self) {}
}
fn f(x: X<State1>) -> X<State2> {
let X { a, b, c, _d } = x;
//mutate a, b and c
X {
a,
b,
c,
_d: PhantomData,
} // return new instance
}
因为X实现了Drop，我得到：
use core::marker::PhantomData;
struct State1 …