2015-02-18 8 views

risposta

21

mut foo: T significa avere una variabile chiamata foo che è un T. Hai il permesso di cambiare ciò che la variabile si riferisce alla:

let mut val1 = 2; 
val1 = 3; // OK 

let val2 = 2; 
val2 = 3; // error: re-assignment of immutable variable 

Ciò consente anche di modificare i campi di una struct che si è proprietari:

struct Monster { health: u8 } 

let mut orc = Monster { health: 93 }; 
orc.health -= 54; 

let goblin = Monster { health: 28 }; 
goblin.health += 10; // error: cannot assign to immutable field 

foo: &mut T significa che avete una variabile che fa riferimento (&) un valore e si è permesso di cambiare (mut) il valore di cui (compresi i campi, se si tratta di una struttura):

let val1 = &mut 2; 
*val1 = 3; // OK 

let val2 = &2; 
*val2 = 3; // error: cannot assign to immutable borrowed content 

Nota che &mut senso solo con un riferimento - foo: mut T non è sintassi valida. Puoi anche combinare i due qualificatori (let mut a: &mut T), quando ha senso.

+4

vedo. Immagino sia come in C++ dove puoi avere 'int const *' vs. 'int * const' per ottenere cose diverse. –

+2

@Shepmaster Si potrebbe voler aggiungere che 'mut' su un'associazione ti permette di mutare all'interno della struttura (se è una struttura). –

+0

Suppongo che mi si distingua il motivo per cui la ruggine non sembra consentire la sintassi 'lascia che sia: mut Type '? Sembra che dal momento che abbiamo già l'inevitabile '& mut' in cui' mut' non può apparire sul lato sinistro, è più uniforme dire che 'mut' può apparire solo sul lato destro? –

19

Se arrivate da C/C++, potrebbe anche essere utile pensare ad esso sostanzialmente in questo modo:

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

Noterete che questi sono inverse l'una dell'altra. C/C++ adottare un approccio "lista nera", in cui, se si vuole qualcosa di cui essere immutabili che hai da dire in modo esplicito, mentre Rust adotta un approccio "whitelist", in cui, se si vuole qualcosa di cui essere mutevole che hai da dire in modo esplicito.

Problemi correlati