Início / coding / Perguntas / 79468821
Accepted
Douglas Richard Landa
Asked: 2025-02-26 15:15:53 +0800 CST

Como a mutabilidade funciona com Vec e elementos dentro dele?

  • 772

Não entendi bem a ideia de mutabilidade em Rust na seguinte situação:

  1. Vec mutável com elementos mutáveis
  2. Vec mutável com elementos imutáveis
  3. Vec imutável com elementos mutáveis
  4. Vec imutável com elementos imutáveis.

Até onde eu entendi, se ambos são imutáveis ​​(4), então é apenas um vetor somente leitura. Mas, desde que eu torne o vetor mutável, não importa se os elementos são mutáveis ​​ou não...

Com vetor mutável eu sempre posso mutar elementos mesmo que eu não os tenha tornado mutáveis...

let mut st1 = String::from("Some");
let mut st2 = String::from("Value");

let vec: Vec<&mut str> = vec![&mut st1, &mut st2];

Alguém pode explicar em quais situações as combinações acima devem ser usadas e se há certos limites para cada uma delas?

Muito obrigado!

rust

1 respostas

  1. Best Answer

    Referência de Referência e Mutabilidade

    Então, primeiro você precisa entender, referência de referência

    let mut i: i32 = 0;
{
    let mut r: &i32 = &i;
    *r += 1; //cannot assign to `*r`, which is behind a `&` reference
    let rr: &&i32 = &r;
    **rr += 1; // cannot assign to `**rr`, which is behind a `&` reference
    let mr: &mut &i32 = &mut r;
    **mr += 1; //cannot assign to `**mr`, which is behind a `&` reference
}

let mut m: &mut i32 = &mut i;
*m += 1; // OK
let rm: &&mut i32 = &m;
**rm += 1; // cannot assign to `**rm`, which is behind a `&` reference
let mm: &mut &mut i32 = &mut m;
**mm += 1; // OK

    Isso significa que se você quiser alterar um valor atrás de dois graus de referência, precisará que ambos os graus sejam uma referência mutável.

    Exemplo comVec

    fn main() {
    let mut a: i32 = 0;
    let mut b: i32 = 0;

    // Immutable Vec with Immutable reference element
    {
        let v = vec![&a, &b];
        let _ = v.pop(); // cannot borrow as mutable
        *v[0] += 1; // cannot assign to data in an index of `Vec<&i32>`
    }

    // Mutable Vec with Immutable reference element
    {
        let mut v = vec![&a, &b];
        let _ = v.pop(); // you can mutate the vec itself

        *v[0] += 1; // but not the elements it referenced
        // ^^^^^^^
        // since, this is basically this
        // vvvvvvv
        let r: &mut &i32 = v.get_mut(0).unwrap();
        **r += 1;
        // cannot assign to `**r`, which is behind a `&` reference
    }

    // Immutable Vec with Mutable reference element
    {
        let v = vec![&mut a, &mut b];
        let _ = v.pop();
        *v[0] += 1;

        let r: &mut &mut i32 = v.get_mut(0).unwrap();
                            // ^ cannot mutate immutable variable `v`
                            // since v is immutable, you cannot mutably borrow v
        **r += 1;
    }

    // Mutable Vec with Mutable reference element
    {
        let mut v = vec![&mut a, &mut b];
        let _ = v.pop();
        *v[0] += 1;

        let r: &&mut i32 = v.get(0).unwrap();
        **r += 1;
        // cannot assign to `**r`, which is behind a `&` reference

        let r: &mut &mut i32 = v.get_mut(0).unwrap();
        **r += 1;
    }
}
    • 1

relate perguntas