根据
Rust中的每个值都有一个称为所有者的变量。一次只能有一个主人。当所有者超出范围时,该值将被删除。
根据
静态项不会在程序结束时调用drop。
在阅读了之后,并给出了下面的代码,我了解到foo是一个值,其变量y与自以来的&y等效,称为owner。对吗?还是静态项目没有所有者?
let x = String::from("foo"); // heap allocated, mutable, owned
let y = "foo" // statically allocated to rust executable, immutabl
我来自PHP,刚进入锈菌领域,我正试图将我遗留的PHP代码“移植”到Rust。虽然我花了很多周的时间尝试深入文档并尝试用Rust编写代码,但它根本不会编译。
我已经尝试了所有可以找到的选项,包括Rc<RefCell<x>>构造。显然,PHP代码的设计很糟糕,但我看不出如何改进它。任何指向正确方向的指示都将受到极大的赞赏!
PHP:
class Database {
function build_row() : Row {
return new Row($this);
}
}
class Row { // with AR properties
pro
这段代码应该是一个简单的while循环。在我输入“退出”这个词之前,它应该继续输入一个名字列表,然后打印出向量。我用这个来测试我对借贷的理解。
use std::io;
fn main() {
let mut name = String::new();
let mut vec = Vec::new();
while name.ne("exit") {
print!("Enter a name");
io::stdin().read_line(&mut name).expect("f
我正在从学习Rust,但遇到了一个问题,编译器的行为不像第4章第77页中所解释的那样。
本书的第4章讨论了所有权,第77页上的例子与此类似,没有main()中的最后一个main()(我还添加了注释和第76页中的函数来创建一个MCVE)。。
fn main() {
let mut s = String::from("Hello world!");
let word = first_word(&s);
// according to book, compiler should not allow this mutable borrow
//
在Rust中,如果我想要跨多个上下文对一个&str进行只读访问而不复制实际的底层数据,那么我认为我只使用一个片段是正确的吗?
示例
let original_string = "here's a string";
let slice = &original_string[0..3];
还是需要像Rc<str>这样的东西?
作为学习练习的一部分,我正在使用Rust实现一个编译器。对于编译器的一部分,我实现了令牌窥视,以执行高效的解析器替换。为了在Rust中做到这一点,我查看了令牌堆栈,然后匹配令牌,这将产生一个嵌套的匹配语句,如下所示。
// Is there an optional type modifier
// Peek at the next token and process it
match tokens.last() {
Some(token) =>
match token.clone() {
lexer::Token::OpenBracket
我想数数一个大字符串中单词的频率。
简单的单线程解决方案如下所示
use hashbrown::HashMap;
fn main() {
let buffer = String::from("Hello World Hello Rust");
let mut frequency: HashMap<&str, u32> = HashMap::new();
for word in buffer.split_whitespace() {
*frequency.entry(word).or_insert(0) += 1;
在Rust中使用Future时,通常会在用lambda实现的链式处理步骤之间传递对象的所有权(例如连接、处理数据等)。我理解这个概念,并且已经做了很多,没有问题。
我也试图这样做,但这一次,部分结果是引用类型。我无法说服锈蚀借用检查器接受以下(过于简化的)代码:
extern crate futures;
use futures::prelude::*;
// Parsed data with attribute values that might be not owned, only referenced
trait Data<'a> {
fn attribut
据我所知,您不允许在Rust中同时创建两个对对象的可变引用。我不完全理解为什么下面的代码可以工作:
fn main() {
let mut string = String::from("test");
let mutable_reference: &mut String = &mut string;
mutable_reference.push_str(" test");
// as I understand it, this creates a new mutable reference (2nd?)
t
在Rust中,是否可以显式地提供有关对象何时过期的上下文?例如,想象一下这样一个图形操作代码:
// borrow an edge from the graph
let edge : &Edge = graph.findEdge( ... );
// modify the edge
let new_edge : &Edge = graph.splitEdge(edge, vertex);
// the old edge is invalid now, this should be an compiler error now!
edge.something
一般来说,有什么方法
我正在尝试建立一个hashmap来计算字符串中的字符频率。我的方法是折叠字符串中的字符,在每次迭代中递增当前字符的计数。不幸的是,rust告诉我,我在贷款方面做了一些错误的事情。
使用clone()或将hm.get(&c)分开放在单独的行上没有任何效果。
我不知道如何避免这个关于两阶段借用的错误。()
use std::collections::HashMap;
fn main() {
let some_str = "some string";
let hm = some_str.chars().fold(HashMap::new(), |mut h
有什么办法可以解决这个问题吗? 可以计算借用的布尔值吗?我对rust还很陌生,所以我可能没有使用正确的术语。 fn control(map: &[bool;5]) -> bool {
let mut hold = false;
for n in map.iter() {
if n {
hold = true;
break;
}
}
hold
}
let type1 = "Hello";
let mut type2 = String::from("World");
type2.push('!'); //Push can only add one single char
type2.push_str(" from Rust"); // push_str adds a string
let len = type2.len(); //Length of type2
let capacity = type2.capacity(); //Capacity in bytes
let c
我是Rust的新手,对这门语言略知一二。我编写了两个简单的函数,在Rc<RefCell<..>>中递增和递减一个值。由于此功能对任何数字类型都有意义,因此我尝试将它们转换为泛型函数: use num::Integer;
// This works fine
pub fn increment_counter(c: &Rc<RefCell<u32>>) {
let new_c = *c.borrow() + 1;
c.replace(new_c);
}
// This does not compile
pub fn de
在以下情况下,我试图了解锈菌的混叠规则:
让我们假设C中有一个内存分配,我们将指向这个分配的指针传递给Rust。Rust函数对分配做一些事情,然后调用C代码(没有任何参数),在C代码中调用另一个铁锈函数,与参数的分配相同。现在,让我们假设只有第一个Rust函数才能得到一个可变的引用。
调用堆栈如下所示:
Some C Code (owns data)
Rust(pointer as &mut)
Some C code (does not get parameters from Rust)
Rust(pointer as &)
作为一个简短的例子,让我们假