Wektory

Podstawowe operacje

Utwórz nowy wektor z wykorzystaniem metody new oraz makra vec!:

// new empty vector
let v: Vec<i32> = Vec::new();
 
// new vector with values
let mut v = vec![1, 2, 3];

Pobierz elementy wektora za pomocą indeksu lub metody get:
```
 let e1 : &i32 = &v[1];
 
 let e2 = v.get(2);
```
Jaka jest różnica pomiędzy tymi metodami? Kiedy, którą należy stosować?

Zmodyfikuj wektor za pomocą metod push i pop:

// adding values to vector
v.push(4);
v.push(5);
 
// removing values
let e = v.pop();

Odwołanie do elementu wektora jest pożyczką, dlatego poniższy kod zakończy się błędem kompilacji:

let mut v = vec![1, 2, 3];
 
let first = &v[0];
 
v.push(4);
 
println!("{}", *first); // uncomment to see the compile error

Iteracja po elementach wektora

W przeciwieństwie do innych języków programowania, w Rust wyróżniamy 3 rodzaje iteracji po elementach wektora, które związane są, a jakże, z własnością i pożyczaniem wartości.

Iteracja po elementach, podobnie jak dopasowanie wzorca, konsumuje wartość, dlatego iterowanie bezpośrednio po wektorze spowoduje, że po zakończeniu iteracji wektor nie będzie już dostępny pod tą zmienną (własność zostanie przeniesione do wnętrza pętli) i prawdopodobnie (jeśli sama wartość nie zostanie zwrócona), wektor po wykonaniu pętli zostanie usunięty.
```
let v = vec![1, 2, 3];
 
for e in v { 
    println!("{}", e); 
}
 
// cannot use v here
// let eo = &v[0]; // will cause an error
```
Aby uniknąć skonsumowania wektora, możemy iterować wykorzystując pożyczkę:
```
let v = vec![1, 2, 3];
 
for e : &i32 in &v { // need to use reference (otherwise the v value is moved)
    println!("{}", *e); // need to explicitly derefer the value
}
```
Zwróć uwagę, że element, po którym iterujemy, jest referencją do elementy wektora. Aby wykorzystać jego wartość, należy wykorzystać operatora dereferencji *.
W powyższym przypadku możesz wykonać iterację, ale nie możesz zmieniać wektora. Aby uzyskać możliwość zmiany elementów wektora należy wykorzystać mutowalną pożyczkę:
```
let mut v = vec![1, 2, 3];
 
for e in &mut v { // mutable borrow
    *e *= 2; // remember to use dereference operator
}
```

Wprowadzenie Mapy