相关疑难解决方法(0)

有人可以解释这两者之间的区别是什么时候mut a: &T最常用的？

有什么区别

let y = &mut 5;
*y += 1;
let x = *y + 1;

和

let mut y = 5;
y += 1;
let x = y + 1;

他们返回相同的结果println!,但我不能决定哪一个更好.

我的 C++ 背景让我对内部可变性感到不舒服。下面的代码是我围绕这个主题的调查。

我同意，从借用检查器的角度来看，处理每个内部状态可能迟早改变的单个结构上的许多引用是不可能的；这显然是内部可变性可以提供帮助的地方。

此外，在第15.5章“RefCell 和内部可变性模式”中锈病编程语言，有关的例子Messenger特质及其对实施 MockMessenger结构让我觉得，这是一种常见的API设计，系统地喜欢&self过&mut self，即使它很明显，迟早会强制要求某种可变性。Messenger发送消息时如何实现不改变其内部状态？例外只是打印消息，这与 一致&self，但一般情况可能包括写入某种内部流，这可能意味着缓冲，更新错误标志......所有这些当然都需要&mut self，例如 impl Write for File.

依靠内部的可变性来解决这个问题听起来好像是，在C ++中，const_cast荷兰国际集团或滥用mutable成员只是因为在申请的其他地方，我们是不是一致 const岬（对于C ++的学习者常犯的错误）。

所以，回到我下面的示例代码，我应该：

• 使用&mut self（编译器不会抱怨，即使它不是强制性的）从change_e()到change_i()为了与我改变存储的整数值的事实保持一致？
• 继续使用&self，因为内部可变性允许它，即使我实际上改变了存储的整数的值？

这个决定不仅对结构本身来说是局部的，而且会对使用这个结构的应用程序中可以表达的内容产生很大的影响。第二种解决方案肯定会有很大帮助，因为只涉及共享引用，但它是否与 Rust 中的预期一致。

我在Rust API Guidelines 中找不到这个问题的答案 。是否有任何其他类似于C++CoreGuidelines 的Rust 文档 ？

/*
    $ rustc int_mut.rs && ./int_mut …

示例代码？

fn main() {
    let a = [1, 2, 3, 4, 5];
    reset(a);
}

fn reset(mut b: [u32; 5]) {
    b[0] = 5;
}

变量a是一个不可变数组，reset函数的参数b是一个可变数组；直觉上我需要修改a为可变数组才能调用该reset方法，但是编译器告诉我不需要这样做，这是为什么呢？

fn main() {
    let mut a = [1, 2, 3, 4, 5];
    reset(a);
}

fn reset(mut b: [u32; 5]) {
    b[0] = 5;
}

fn main() {
    let a = [1, 2, 3, 4, 5];
    reset(a);
}

fn reset(mut b: [u32; 5]) {
    b[0] = …

在此代码,sref1并且sref2是的地址s,和地址是相同的.ref和之间有什么区别&？

fn main() {
    let s = String::from("hello");
    let sref1 = &s;
    let ref sref2 = s;
    println!("{:p}", sref1);
    println!("{:p}", sref2);

    f1(&s);
    f2(s);
}

fn f1(_s: &String) {
    println!("{:p}", _s);
}

fn f2(ref _s: String) {
    println!("{:p}", _s);
}

_sin f1和f2也是字符串的地址,f2将取得所有权,但打印f2的地址与打印的地址不同f1.为什么？

我知道 Rust 引用很像 C 指针，并且我一直将 Rust 引用视为 C 指针。经过一些实验和搜索，我很困惑。

我熟悉 C，并且读过What\'s the Difference between Placeing \xe2\x80\x9cmut\xe2\x80\x9d before a variable name and after the \xe2\x80\x9c:\xe2\ x80\x9d？，给出下表：

\n

// Rust          C/C++\n    a: &T     == const T* const a; // can\'t mutate either\nmut a: &T     == const T* a;       // can\'t mutate what is pointed to\n    a: &mut T == T* const a;       // can\'t mutate pointer\nmut a: &mut T == T* a;             // can mutate both\n

Run Code Online (Sandbox Code Playgroud)\n

谁能解释为什么下面的代码不能编译？

use std::collections::HashMap;

fn add(mut h: &HashMap<&str, &str>) {
    h.insert("foo", "bar");
}

fn main() {
    let mut h: HashMap<&str, &str> = HashMap::new();
    add(&h);
    println!("{:?}", h.get("foo"));
}

这就是 rustc 告诉我的

hashtest.rs:4:5: 4:6 error: cannot borrow immutable borrowed content `*h` as mutable
hashtest.rs:4     h.insert("foo", "bar");
                  ^

我试过了:

let mut vec = [1,2,3];

for mut x in &vec { *x=3; }
for mut &x in &vec { x=3; }
for mut *x in &vec { x=3; }
for mut x in mut &vec { *x=3; }
for mut x in &(mut vec) { *x=3; }

这些都不起作用; 我该怎么办？

我正在阅读The Rust Programming Language 的第二章，我不明白的东西在这里引起了我的注意：

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

io::stdin().read_line(&guess).expect("Failed to read line");