Question

如果我有以下结构：

struct MyStruct { tuple: (i32, i32) };

以下功能：

// This will not compile
fn function(my_struct: &mut MyStruct) {
    let (val1, val2) = my_struct.tuple;
    val1 = 1;
    val2 = 2;
}

如何将val1和val2作为可变对象借用，所以当我重新分配它们时，更改会出现在原始结构中？

Answer 1

你遇到了一些问题：

您已将&mut放在错误的位置; &mut是类型的一部分，而不是参数（除非您对参数进行解构，否则不是）。
您无法调用参数struct，因为这是关键字。
您无法使用直接赋值分配给可变引用。

所以，考虑到这些，这是一个有效的解决方案：

#[derive(Debug)]
struct MyStruct {
    tuple: (i32, i32),
}

fn function(s: &mut MyStruct) {
    let (ref mut val1, ref mut val2) = s.tuple;
    *val1 = 1;
    *val2 = 2;
}

fn main() {
    let mut s = MyStruct { tuple: (0, 0) };
    function(&mut s);
    println!("{:?}", s);
}

这里的关键是模式中的ref以引用方式绑定;将其与mut结合使用可为您提供可变参考。具体来说，它会为您提供一对&mut i32 s。由于这些是引用，您必须取消引用它们才能通过它们进行分配（否则，您将尝试重新分配引用本身）。

Answer 2

你有两个略有不同的问题。

您可以通过说mut两次来创建可变绑定：

fn main() {
    let a = (1, 2);
    let (mut b, mut c) = a;
    b += 1;
    c += 2;

    println!("{}, {}", b, c);
}

但要在原始元组中进行更改，您需要可变引用进入该元组：

fn main() {
    let mut a = (1, 2);

    {
        let (ref mut b, ref mut c) = a;
        *b += 1;
        *c += 2;
        // Let mutable borrows end
    }

    println!("{:?}", a);
}

如何构造元组以使绑定可变？

2 个答案: