Vediamo di commentare passo passo:
// Crea un vettore contenente numeri da 1 a max.
std::vector<int> numbers(max);
for (int i = 0; i < max; ++i) {
numbers[i] = i + 1;
}
std::vector<T> è un vettore di elementi di tipo T. Più o meno è equivalente agli array C-style (T numbers[max];). Gli elementi sono accessibili dall'indice 0 all'indice max-1 ma, dato che le palline nel lotto partono da 1, alla posizione i-esima c'è la pallina i+1-esima (in effetti credo sia più chiaro così che nel mio primo esempio).
Quindi il vettore numbers contiene:
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
...
numbers[89] = 90;
A questo punto mischiamo il vettore con std::random_shuffle() (http://en.cppreference.com/w/cpp/algorithm/random_shuffle), in questo modo il vettore sarà ordinato casualmente.
Gli algoritmi della libreria standard di norma prendono come parametri degli iteratori. Cosa sia un iteratore è un po' complesso, ma in sostanza è la generalizzazione di un puntatore ad un elemento di un array. Un iteratore "punta" ad un elemento di un contenitore. Incrementando l'iteratore si ottiene l'elemento successivo, decrementandolo si ottiene l'elemento precedente. Dereferenziandolo (con l'operatore *) si ottiene l'elemento puntato.
int array[4] = {1, 2, 3, 4};
int * inizio = & array[0]; // *inizio = 1
int * i = inizio; // *i = 1
i++; // *i = 2
int * fine = inizio + 4; // fine punta appena oltre la fine dell'array
fine--; // *fine = 4
std::vector<int> vettore = {1, 2, 3, 4}; // In realtà questa inizializzazione non è possibile,
// ma assumi che contenga quegli elementi.
std::vector<int>::iterator inizio = vettore.begin(); // *inizio = 1
std::vector<int>::iterator i = inizio; // *i = 1
i++; // *i = 2
std::vector<int>::iterator fine = inizio + 4; // fine punta appena oltre la fine del vettore
fine--; // *fine = 4
Quindi la linea seguente mischia tutti gli elementi compresi tra l'inizio e la fine del vettore (cioè tutti gli elementi del vettore):
std::random_shuffle(numbers.begin(), numbers.end());
Alla fine si crea un altro vettore di n elementi e ci si copiano dentro i primi n elementi del vettore numbers, che saranno casuali. std::copy() funziona sempre con gli iteratori: copia dall'inizio del vettore fino all'inizio del vettore più n posizioni, a partire dall'inizio del vettore 'result'.
std::vector<int> result(n);
std::copy(numbers.begin(), numbers.begin() + n, result.begin());
È ancora equivalente ad usare array C-style:
int vettore[10] = {...};
int result[3];
int * inizio_vettore = & vettore[0];
int * inizio_result = & result[0];
std::copy(inizio_vettore, inizio_vettore + 3, inizio_result)
// Oppure
int * i, *j;
for (i = inizio_vettore, j = inizio_result; i != inizio_vettore + 3; ++i, ++j) {
*j = *i;
}
In effetti in questo particolare esempio è un'operazione inutile, sarebbe meglio semplicemente ridurre la dimensione del vettore numbers e restituire quest'ultimo. Ma nel caso volessi fare più estrazioni allora l'esempio sarebbe perfetto.
L'ultimo blocco nel main() serve a stampare i risultati. Nota che uso const_iterator e non iterator perché non mi serve modificare gli elementi.
std::vector è definito nell'header <vector>
std::random_shuffle() e std::copy() sono definite nell'header <algorithm>
std::cout è definito nell'header <iostream>
std::srand() è definita nell'header <cstdlib>
std::time() è definita nell'header <ctime>
Quindi servono tutti gli header (anche se alcuni compilatori potrebbero essere poco severi nel caso ne manchi qualcuno).
std::vector indica che il simbolo 'vector' (in questo caso una classe template) sta nel namespace 'std' (che è il namespace della libreria standard). I namespace permettono di avere simboli con lo stesso nome (ad esempio puoi scrivere la tua classe 'vector', purché sia definita in un namespace diverso).
Usare "using namespace std;" non è considerata una buona pratica perché equivale a non usare namespace. In ogni caso non usarlo mai in un header, poiché si propagherebbe in tutti i file che lo includono.
std::vector è una classe che rappresenta un vettore, così come std::list rappresenta una lista, std::stack una pila, std::queue una coda... In C++ non dovresti mai usare array C-style direttamente, queste classi li incapsulano offrendo un'interfaccia più sicura.