Perché è possibile ripetere due volte una porzione, ma non un vettore?

Question

Se provo a iterare su una fetta due volte, it works fine:

let a = &[1, 2, 3]; 
for i in a { 
    println!("{}", i); 
} 
for i in a {   // works fine 
    println!("{}", i); 
} 

Ma se provo a iterare su un vettore due volte, it fails:

let a = vec![1, 2, 3]; 
for i in a { 
    println!("{}", i); 
} 
for i in a {   // error: use of moved value: `a` 
    println!("{}", i); 
} 

vedo che il tratto IntoIterator prende self da valore, quindi ha senso per me che il secondo esempio fallisce. Ma perché il primo esempio ha successo?

Answer 1

Come hai detto tu, for opere prendendo la cosa hai chiesto a iterare, e passando attraverso IntoIterator::into_iter per produrre il valore iteratore reale. Inoltre, come hai detto, into_iter prende il soggetto in base al valore.

Così, quando si tenta di iterare su una Vector direttamente, questo significa che si passa l'intero vettore, per valore, nella sua IntoIterator realizzazione, consumando così il vettore nel processo. Ecco perché non è possibile eseguire iterazioni su un vettore direttamente due volte: iterandolo su di esso la prima volta che lo consuma, dopo di che non esiste più.

Tuttavia, le sezioni sono diverse: una sezione è un puntatore immutabile, preso in prestito ai suoi dati; puntatori immutabili e presi in prestito possono essere copiati liberamente. Ciò significa che il IntoIterator per le sezioni immutabili prende in prestito i dati e non li consuma (non che sia ). Oppure, per guardarlo in un altro modo, la sua implementazione IntoIterator sta semplicemente prendendo una copia della sezione, mentre non è possibile copiare uno Vec.

Va notato che si può iterare su una Vecsenza consumarlo entro l'iterazione di un prestito. Se controlli lo documentation for Vec, noterai che elenca le implementazioni di IntoIterator per Vec<T>, &Vec<T> e &mut Vec<T>.

let mut a: Vec<i32> = vec![1, 2, 3]; 

for i in &a {   // iterate immutably 
    let i: &i32 = i; // elements are immutable pointers 
    println!("{}", i); 
} 

for i in &mut a {  // iterate mutably 
    let i: &mut i32 = i;// elements are mutable pointers 
    *i *= 2; 
} 

for i in a {   // iterate by-value 
    let i: i32 = i;  // elements are values 
    println!("{}", i); 
} 

// `a` no longer exists; it was consumed by the previous loop.