Jak mogę zniszczyć krotkę, aby powiązania były zmienne?

Question

Jeśli mam następujące struct:

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

oraz następujące funkcje:

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

Jak mogę pożyczyć VAL1 i val2 jako zmienny więc kiedy przypisanie do nich zmiany są wyświetlane w oryginalnej struktury?

Answer 1

Masz kilka problemów:

• Umieściłeś &mut w niewłaściwym miejscu; &mut jest częścią typu, a nie argumentem (chyba że destrukturyzujesz argument, którym nie jesteś). Nie można wywołać argumentu struct, ponieważ jest to słowo kluczowe.

• Nie można przypisać do zmiennej referencyjnej z prostym przyporządkowaniem.

Tak, z tych na uwadze, oto roztwór roboczy:

#[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); 
} 

Kluczem tutaj jest to, że ref w układzie wiąże się przez odwołanie; łącząc to z mut daje zmienną referencję. W szczególności daje parę &mut i32 s. Ponieważ są to odniesienia, musisz odwołać je, aby je przypisać (w innym przypadku próbujesz ponownie przypisać odniesienie).

Answer 2

Masz dwa nieco inne pytania.

Można utworzyć zmienny wiążą mówiąc mut dwukrotnie:

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

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

Ale aby to zmienić w oryginalnym krotki, trzeba zmienny odniesienie do tego krotki:

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); 
}