来自C++,我很惊讶这段代码在Rust中是有效的:
let x = &mut String::new();
x.push_str("Hello!");
在C++中,你不能取一个临时的地址,一个临时的不会比它出现的表达式更长.
临时居住在Rust多久了？既然x只是借用,谁是字符串的所有者？
我正在尝试实现一个常用的模式 - 在下一个循环迭代中使用上一个循环迭代的结果。例如，要实现分页，您需要给出上一页上最后一个值的 id。
struct Result {
str: String,
}
fn main() {
let times = 10;
let mut last: Option<&str> = None;
for i in 0..times {
let current = do_something(last);
last = match current {
Some(r) => Some(&r.str.to_owned()),
None => None,
};
}
}
fn do_something(o: Option<&str>) -> Option<Result> {
Some(Result {
str: "whatever string".to_string(),
})
}
但是，我不确定如何真正从循环中获取值。目前，编译器错误是temporary value dropped while borrowed(at &r.str.to_owned())，虽然我做了很多其他尝试，但都无济于事。
我发现真正让它工作的唯一方法是创建某种局部tmp_str变量并像这样进行黑客攻击：
match current {
Some(r) => {
tmp_str.clone_from(&r.str);
last = …问题：我从一个方法中得到一个“XXXXXXX 下降到这里仍然借用”错误，其中 XXXXXXX 在方法结束时有效（这很好），但是 Rust 不必要地期望它只要输入引用就可以存活因为那些有明确的生命周期。
这是一些设置信息：我有一个结构体，它在文本内容中迭代所有找到的查询。
pub struct QueryRangeItr<'a> {
inverted: bool,
query: &'a str,
content: &'a str,
}
它需要查询和内容的引用，并期望实例与查询/内容一样长。到现在为止还挺好。
impl<'a> QueryRangeItr<'a> {
fn new(query: &'a str, content: &'a str, inverted: bool) -> QueryRangeItr<'a> {
Self {
inverted,
query,
content,
}
}
}
我有一个静态方法，允许您对每个找到的查询执行转换。它接受一个闭包并将其应用于查询，然后为您提供一个String没有生命周期依赖的 new 。因为返回值没有生命周期，我实际上并不想在这里为查询和内容带来生命周期，但如果我不这样做，Rust 告诉我我需要......因此，它们有生命周期要求。就其本身而言，这很好用。
问题发生在另一个静态方法上，该方法调用transform两次以转换查询和非查询内容。它首先调用transfrom对找到的查询应用一个闭包。结果将反馈到该transform方法的另一个调用，但这次将转换应用于其余内容。
impl<'a> QueryRangeItr<'a> {
pub fn transform<T>(
query: &'a str,
content: &'a str,
transform: T,
inverted: bool,
) -> String …我有一个接收一些参数的函数，但是当我尝试使用该参数时，它会抛出错误。
// 功能
pub fn solc_compile(compiler: &str, file: &str, out: &str, config: templates::Config) {
let mut args = vec![
"--bin",
"--abi",
"--include-path",
"./libs",
"--include-path",
"./node_modules",
"--output-dir",
out,
];
if config.compiler.optimize {
let runs: &str = config.compiler.runs.to_string().as_str();
args.push("--optimize");
args.push("--optimize-runs");
args.push(runs);
}
}
// 在函数参数上使用的配置类型（config templates::Config）。
模板.rs
// config templates.
#[derive(Deserialize, Serialize)]
pub struct Config {
pub info: ConfigInfo,
pub compiler: ConfigCompiler,
}
// config.info templates.
#[derive(Deserialize, Serialize)]
pub struct ConfigInfo {
pub name: String,
pub license: String,
}
// config.compiler templates. …我有以下代码:
pub struct Canvas<'a> {
width: isize,
height: isize,
color: Color,
surface: Surface,
texture: Texture,
renderer: &'a Renderer,
}
impl<'a> Canvas<'a> {
pub fn new(width: isize, height: isize, renderer: &'a Renderer) -> Canvas<'a> {
let color = Color::RGB(0, 30, 0);
let mut surface = core::create_surface(width, height);
let texture = Canvas::gen_texture(&mut surface, width, height, color, renderer);
Canvas {
width: width,
height: height,
color: color,
surface: surface,
texture: texture,
renderer: renderer,
}
}
pub fn color(&mut self, color: Color) -> &mut Canvas<'a> …我正在努力实现一个简单的建设者,但却终身难忘.以下是给予error: borrowed value does not live long enough.这个问题似乎很相似.如果我存储t在一个可变变量然后调用s并最终确定它是有效的,但我想让一个衬里工作.我究竟做错了什么？
struct Type<'a> {
s: &'a String,
}
struct TypeBuilder {
s: String,
}
impl TypeBuilder {
fn new() -> TypeBuilder {
TypeBuilder { s: "".to_string() }
}
fn s(&mut self, s: String) -> &mut TypeBuilder {
self.s = s;
self
}
fn finalize(&self) -> Type {
Type { s: &self.s }
}
}
fn main() {
let t = TypeBuilder::new()
.s("a".to_string())
.finalize();
println!("string: {}", …我正在学习 Rust（来自 Javascript），并且在 Rust 中我尝试创建一个基于组件的 UI 模板。这是我可以在 Rust 游乐场中重现的最小示例。
我有一个枚举向量。我想添加将返回一组新向量的组件。该组件从不是引用的成员函数返回一个向量。
let _new_children = match new_view.unwrap() {
View::View(children) => children, // reference &Vec<View>
View::Render(ref component) => component.render(), // struct Vec<View>
};
let _new_children = match new_view.unwrap() {
View::View(children) => children,
View::Render(ref component) => &component.render(), // temporary value dropped while borrowed
};
我怎么解决这个问题？我是否需要重写函数检查两个向量之间差异的方式（itertools有一个 zip_longest 方法，我也使用该方法）。
请考虑以下示例（游乐场）：
struct Animal<'a> {
format: &'a dyn Fn() -> (),
}
impl <'a>Animal<'a> {
pub fn set_formatter(&mut self, _fmt: &'a dyn Fn() -> ()) -> () {} // Getting rid of 'a here satisfies the compiler
pub fn bark(&self) {}
}
fn main() {
let mut dog: Animal = Animal { format: &|| {()} };
let x = 0;
dog.set_formatter(&|| {
println!("{}", x); // Commenting this out gets rid of the error. Why?
});
dog.bark(); // Commenting this …我遇到这个问题，因为我正在解构的变量是借用的（？）并且不能在其他方法中使用。这听起来像是一个非常典型的用例，但我不确定如何解决它。
\n`\xe2\x9e\x9c hello_cargo git:(master) \xe2\x9c\x97 cargo build\n Compiling hello_cargo v0.1.0 (/Users/johnny/Projects/hello_cargo)\nerror[E0716]: temporary value dropped while borrowed\n --> src/main.rs:24:39\n |\n24 | let DBAndCFs { db: _, cfs } = self.db.lock().as_ref().unwrap();\n | ^^^^^^^^^^^^^^ - temporary value is freed at the end of this statement\n | |\n | creates a temporary which is freed while still in use\n25 | cfs.len()\n | --------- borrow later used here\n |\n = note: consider using a `let` binding to create a longer lived value\n`\n这是生成此问题的代码： …