Vectorii în C++: declarare și parcurgere

Știm să lucrăm cu numere individuale, însă de multe ori este necesar să lucrăm cu un șir de numere. Aici intervin vectorii, sau tablourile unidimensionale, care ne permit lucrul cu un număr variabil de elemente.

Declararea unui vector

Pentru a declara un vector/tablou unidimensional în C++, avem următoarea structură:

tip nume[lungime];

Spre exemplu, următoarea structură delcară un vector de numere întregi (int), numit a, și cu dimensiunea de 10:

int a[10];

Mai precis, în memorie, calculatorul a creat un spațiu unde putem să stocăm 10 numere de tip int. Iată un exemplu de astfel de vector (cu elemente alese aleatoriu).

Pentru a identifica câte un element din vector, fiecare are atribuit câte un indice, număr între 0 și lungime - 1 = 9.

Cum luăm un element din vector

Să zicem că vrem să luăm un element din vectorul nostru (element pe care putem să îl citim de la tastatură, să îl afișăm pe ecran, să îi atribuim o valoare — exact ca la numere normale). Pentru asta, putem folosi operatorul de indexare, care ne dă elementul din vector cu indicele dat. Iată cum luăm, spre exemplu, elementul cu indicele 8 din vector:

a[8] //care este egal cu 55

Practic, am luat din vectorul a, elementul cu indicele 8.

Ce se întâmplă dacă depășim lungimea vectorului?

Să zicem că avem următoarea secvență de cod, care declară un vector cu 10 elemente (cu indicii între 0 și 9) și citește elementul cu indicele 9999:

int a[10];
cin >> a[9999];

Acest program, deși sintactic corect, o să aibă un program impredictibil când se rulează, deoarece se iese din zona de memorie alocată vectorului. Astfel, trebuie avut grijă ca lungimea vectorului să fie destul de încăpătoare pentru a ține toate elementele dorite.

Așadar, dacă o problemă menționează că lungimea unui vector (de regulă notată cu n) are o limită maximă (cum ar fi n ≤ 1000), vectorul va trebui să aibă lungimea de minimum acest număr pentru ca operațiile cu vectorul să meargă cum sunt intenționate.

Parcurgerea unui vector

Am învățat cum putem să luăm elementele unui tablou unidimensional și să aplicăm diverse operații cu acestea:

a[5] = 4; //Elementul cu indicele 5 din vectorul a primește valoarea 4
cin >> a[0]; //Citim de la tastatură elementul cu indicele 0 din vectorul a
cout << a[3]; //Afișăm pe ecran elementul cu indicele 3 din vectorul a

Putem să parcurgem elementele vectorului folosind o structură repetitivă de tip for.

Să presupunem că avem un vector a de lungime n, cu 1 ≤ n ≤ 100 (astfel, lungimea tabloului a trebuie să fie de minimum 100). Ca să luăm elementele în ordine (cel cu indicele 0, cel cu indicele 1 și așa mai departe, până la cel cu indicele n - 1), putem parcurge cu ajutorul unui for astfel:

int a[100], n;
cin >> n; //Citim n (lungimea șirului), care este cel mult 100
for(int i = 0; i < n; i++) { //i de la 0 la n - 1
    a[i] = 0;
}

Exemplul anterior setează toate elementele șirului de la 0 la n - 1 cu 0.

Indexarea unui vector de la 1

Observăm că elementele vectorului sunt indexați de la 0 (au indicii de la 0 la n - 1), deoarece vectorul are indicii de la 0. Cu toate acestea, poate fi cam dificil lucrul de la 0, așadar recomandăm lucrul cu indicii de la 1 la n. Mai exact, nu vom utiliza elementul cu indicele 0 din vector, iar vectorul trebuie să aibă lungimea cu 1 mai mare (ca să încapă și elementul n). Iată aceeași parcurgere de mai sus, doar că cu indexarea de la 1:

int a[101], n; //Creștem lungimea tabloului a cu 1
cin >> n; //Citim n (lungimea șirului), care este cel mult 100
for(int i = 1; i <= n; i++) { //i de la 1 la n
    a[i] = 0;
}

Codul acesta este mult mai ușor de înțeles. De menționat că ambele variante sunt la fel de corecte, iar utilizarea unui element în plus în vector în a doua variantă consumă doar puțin mai multă memorie (fiind neglijabil).

Citirea unui vector

Citirea unui vector presupune parcurgerea elementelor sale și citirea lor pe rând. Nu se poate citi ca la numere: cin >> a.

Iată citirea celor n elemente ale unui vector:

int a[101], n;
cin >> n; //Citim n (lungimea șirului)
for(int i = 1; i <= n; i++) {
    cin >> a[i]; //Citim elementele pe rând: a[1], a[2], …, a[n]
}

Afișarea unui vector

Similar, afișarea elementelor unui tablou unidimensional se realizează astfel:

int a[101], n;

for(int i = 1; i <= n; i++) {
    cout << a[i] << " "; //Afișăm elementele pe rând: a[1], a[2], …, a[n]
}

Afișăm câte un spațiu după fiecare element pentru a le putea separa între ele.

Inițializarea unui vector gol

Dacă vrem să inițializăm un vector gol, putem să egalăm la intrare vectorul cu {0} (echivalent cu un vector cu toate elementele egale cu 0):

int a[100] = {0};

Similar, putem să declarăm un vector cu primele elemente predefinite (și restul egale cu 0):

int b[100] = {2, 4, 6, 8}; //b = {2, 4, 6, 8, 0, 0, 0, …, 0} (restul elementelor sunt 0)

Dacă nu specificăm lungimea la declarare, vectorul va avea fix lungimea dată:

int c[] = {2, 4, 6, 8}; //c = {2, 4, 6, 8} are lungimea egală cu 4
//c[0] = 2, c[1] = 4, c[2] = 6, c[3] = 8

Problemă rezolvată

Inversarea unui vector (afișare inversă)

Dându-se un tablou unidimensional de dimensiune n (n ≤ 100), să se afișeze elementele sale în ordine inversă.

Exemplu: Pentru șirul a = (1, 2, 3, 4) de lungime n = 4, rezultatul va fi 4 3 2 1.

Rezolvare: Citim n și cele n elemente ale lui a folosind o structură repetitivă de tip for (cu i de la 1 la n), după care afișăm elementele sale folosind un for de la n la 1 (descrescător).

#include <iostream>

using namespace std;

int main()
{
    int a[101], n;
    cin >> n;
    for(int i = 1; i <= n; i++) { //i = 1, 2, 3, …, n - 1, n
        cin >> a[i];
    }
    for(int i = n; i >= 1; i--) { //i = n, n - 1, n - 2, …, 2, 1
        cout << a[i] << " ";
    }
    return 0;
}

Exercițiu propus

for(int i = ???; i >= 0; i--) {
    cout << a[i] << " ";
}

Probleme propuse

Alte resurse sau bibliografie

• PbInfo: Declararea și parcurgerea tablourilor unidimensionale
• Cplusplus.com: Tablouri
• Cpplevelzero: Citirea unui vector