Array-uri

Un array reprezintă un set de date de același tip. Definiția formală a unui array arată astfel:

tip_variabilă nume_array [dimensiune_array]

După tipul variabilei urmează numele array-ului, iar apoi, între paranteze pătrate, dimensiunea acestuia. De exemplu, definim un array de 4 numere:

int numbers[4];

Numărul de elemente al array-ului poate fi definit și printr-o constantă:

const int n = 4;
int numbers[n];     // conține 4 elemente

Unii compilatori (de exemplu, G++) acceptă și stabilirea dimensiunii prin variabile. Acest array are patru numere, dar toate aceste numere au valori nedefinite. Pentru a seta valorile elementelor array-ului, se folosesc acolade (inițializator), în interiorul cărora sunt listate valorile pentru fiecare element:

int numbers[4] {};   //  {0, 0, 0, 0}

În acest caz, acoladele sunt goale, deci toate elementele array-ului primesc valoarea zero.

De asemenea, putem specifica valori concrete pentru toate elementele array-ului:

int numbers[4] {1, 2, 3, 4};

În acest caz, în memorie este alocată o zonă compusă din patru celule a câte 4 octeți (mărimea tipului int), fiecare celulă conținând un anumit element al array-ului.

Dacă numărul de valori din inițializator este mai mic decât numărul de elemente din array, atunci valorile sunt atribuite primelor elemente, iar restul primesc valoarea zero:

int numbers[4] {1, 2};   //  {1, 2, 0, 0}

Dacă numărul de valori din inițializator este mai mare decât numărul de elemente din array, atunci la compilare va apărea o eroare:

int numbers[4] {1, 2, 3, 4, 5, 6};   // ! Eroare

În acest exemplu, array-ul are dimensiunea 4, însă i se atribuie 6 valori.

Dacă dimensiunea array-ului nu este specificată în mod explicit, aceasta este dedusă automat din numărul valorilor furnizate:

int numbers[] {1, 2, 3, 4, 5, 6};

În acest caz, array-ul conține 6 elemente.

Totodată, nu este permisă atribuirea unui array către alt array:

int nums1[] {1,2,3,4,5};
int nums2[] = nums1;    // eroare

Indecși - Accesarea și modificarea elementelor array-ului

După definirea unui array, putem accesa elementele sale individuale prin intermediul indecșilor. Indecșii încep de la zero, așadar pentru a accesa primul element, trebuie să folosim indexul 0. Accesând un element după index, putem fie să obținem valoarea lui, fie să o modificăm.

De exemplu, pentru a obține al doilea element (indexul 1):

int n = numbers[1];

Modificarea valorii celui de-al doilea element:

numbers[1] = 123;

Un exemplu complet de accesare și modificare a valorilor:

#include <iostream>
 
int main()
{
    int numbers[4]{1,2,3,4};
    int first = numbers[0];     // obținem primul element
    std::cout << first << std::endl;    // 1
    numbers[0] = 34;                    // modificăm valoarea elementului
    std::cout << numbers[0] << std::endl; // 34
}

La accesarea prin index, trebuie avut în vedere că nu putem accesa un index inexistent. Dacă array-ul are 4 elemente, putem folosi doar indecșii de la 0 la 3. Utilizarea unui index în afara acestor limite va duce la eroare:

int numbers[4]{1,2,3,4};
int forth = numbers[4];     // !Eroare - array-ul are doar 4 elemente (0-3)

Array-uri constante

Dacă dorim ca valorile elementelor unui array să nu poată fi modificate, putem declara array-ul ca fiind constant folosind cuvântul cheie const:

const int numbers[4]{1,2,3,4};
// numbers[1] = 23;    // eroare - valorile elementelor nu pot fi modificate

Dimensiunea array-ului

Dimensiunea (lungimea) unui array nu este întotdeauna cunoscută dinainte. Totuși, putem avea nevoie să o obținem. Există mai multe metode pentru asta.

• Cu sizeof (stil C)

#include <iostream>
  
int main()
{   
    int numbers[]{11, 12, 13, 14};
    std::cout << "Length: " << sizeof(numbers) / sizeof(numbers[0]) << std::endl;   // Length: 4
}

Aici, lungimea array-ului este determinată împărțind dimensiunea totală a array-ului (în octeți) la dimensiunea unui singur element. Deoarece toate elementele au același tip, rezultatul este numărul de elemente.

• Cu funcția std::size() (C++17+)

#include <iostream>
  
int main()
{   
    int numbers[]{11, 12, 13, 14};
    int count = std::size(numbers);
    std::cout << "Length: " << count << std::endl;   // Length: 4
}

Parcurgerea array-urilor

Folosind bucle, putem itera prin întregul array și, prin intermediul indecșilor, accesa elementele acestuia:

#include <iostream>
  
int main()
{   
    const int n = 4;
    int numbers[n] {11, 12, 13, 14};
    for(int i = 0; i < n; i++)
    {
        std::cout << numbers[i] << std::endl;
    }
}

Pentru a parcurge un array într-o buclă, trebuie să cunoaștem lungimea acestuia. În exemplul de mai sus, lungimea este definită prin constanta n. Apoi, în cadrul buclei for, iterăm prin toate elementele, până când contorul i devine egal cu lungimea array-ului.

Ca rezultat, în consolă vor fi afișate toate elementele array-ului:

11  
12  
13  
14

Un alt exemplu – calculul sumei elementelor array-ului

#include <iostream>
  
int main()
{   
    int numbers[]{1, 2, 3, 4};
    int sum {};
    for (int i {}; i < std::size(numbers); sum += numbers[i++]);
    std::cout << "Sum: " << sum << std::endl;   // Sum: 10
}

În acest exemplu, lungimea array-ului este determinată dinamic – folosind funcția std::size().

Buclele pot conține instrucțiuni compacte, ca în cazul de mai sus: contorul i este incrementat în cadrul expresiei sum += numbers[i++], iar bucla for nu are un bloc de cod explicit (instrucția se termină cu ;, deci se execută totul într-o singură linie).

Parcurgerea elementelor în stilul for-each

Folosim o altă formă a buclei for, care este destinată special parcurgerii secvențelor, inclusiv a array-urilor:

#include <iostream>
 
int main()
{
    int numbers[4] {1,2,3,4};
    for(int n : numbers)
    {
        std::cout << n << std::endl;
    }
}

La parcurgerea array-ului, fiecare element parcurs va fi plasat în variabila n, a cărei valoare este afișată în consolă în cadrul buclei.

Dacă nu cunoaștem tipul obiectelor din array, putem folosi specificatorul auto pentru determinarea tipului:

for(auto n : numbers)
{
    std::cout << n << std::endl;
}

Citirea valorilor unui array de la consolă

Asemănător cu modul în care se citesc date pentru variabile individuale, putem introduce valori pentru elementele individuale ale unui array. De exemplu, să presupunem că utilizatorul introduce valorile pentru un array numeric:

#include <iostream>
  
int main()
{
    const int max {6};     // lungimea maximă a array-ului – nu mai mult de 6 numere
    int numbers[max];       // array pentru introducerea numerelor
  
    int i{};        // contorul numerelor introduse
    std::cout << "Enter numbers" << std::endl;
    while(i < max)
    {
        std::cin >> numbers[i];    // introducem un număr
        i++;
    }
    // afișăm array-ul
    for (i = 0; i < max; ++i)
    {
        std::cout << numbers[i] << "\t";
    }
    std::cout << std::endl;
}

În acest exemplu, în buclă se introduc mai întâi șase numere, câte unul pentru fiecare element al array-ului, apoi acest array este afișat.