std::array în C++

#include <array>

std::array<T, N> nume{v1, v2, ...};
void fill(const T& valoare);

Ce face std::array

std::array<T, N> ține exact N elemente de tip T. Dimensiunea face parte din tip și nu se poate schimba: nu are push_back sau erase. Este la fel de rapid ca un tablou C (int t[5]), dar știe cât este de mare (size()), se poate copia cu =, se poate compara cu == și se poate returna dintr-o funcție.

Elementele stau de obicei pe stivă, nu în memoria dinamică, deci N trebuie să fie mic sau moderat. Ai la dispoziție at() (cu verificare), operator[], front, back, data, begin/end și fill(valoare), care pune aceeași valoare în toate pozițiile.

Atenție: std::array<int, 5> a; fără acolade lasă numerele neinițializate (ca un tablou C). Scrie std::array<int, 5> a{}; ca să pornești de la zerouri.

Parametri

Parametru	Descriere
T	Tipul elementelor.
N	Numărul de elemente, o constantă cunoscută la compilare.
valoare	Pentru fill: valoarea scrisă în toate elementele.

Ce returnează

Un obiect std::array. fill nu returnează nimic.

Exemple

Exemplul 1: Zilele săptămânii

#include <array>
#include <print>
#include <string_view>

int main() {
    std::array<std::string_view, 7> zile{"luni", "marți", "miercuri", "joi", "vineri", "sâmbătă", "duminică"};
    std::println("O săptămână are {} zile.", zile.size());
    std::println("Prima: {}, ultima: {}", zile.front(), zile.back());
    for (auto zi : zile) {
        std::print("{} ", zi);
    }
    std::println();
}

Rezultat

O săptămână are 7 zile.
Prima: luni, ultima: duminică
luni marți miercuri joi vineri sâmbătă duminică

Exemplul 2: fill, copiere și comparare

#include <array>
#include <print>

int main() {
    std::array<int, 5> locuri{};     // toate 0
    locuri.fill(1);                  // toate locurile libere
    auto copie = locuri;             // un tablou C nu se poate copia așa
    copie[2] = 0;                    // ocupăm locul 3
    std::println("{} {}", locuri, copie);
    std::println("Sunt egale? {}", locuri == copie);
}

Rezultat

[1, 1, 1, 1, 1] [1, 1, 0, 1, 1]
Sunt egale? false

Exemplul 3: at() și returnarea dintr-o funcție

#include <array>
#include <print>
#include <stdexcept>

std::array<int, 3> rgb(int cod) {
    return {(cod >> 16) & 0xFF, (cod >> 8) & 0xFF, cod & 0xFF};
}

int main() {
    auto culoare = rgb(0xFF8800);
    std::println("RGB: {}", culoare);
    try {
        std::println("{}", culoare.at(3));
    } catch (const std::out_of_range&) {
        std::println("Poziția 3 nu există într-un std::array de 3 elemente.");
    }
}

Rezultat

RGB: [255, 136, 0]
Poziția 3 nu există într-un std::array de 3 elemente.

Greșeli frecvente

• Declari std::array<int, 4> a; și citești valorile: sunt neinițializate (gunoi). Folosește a{} sau fill.
• Încerci să folosești o variabilă ca dimensiune: std::array<int, n> cu n citit de la tastatură nu compilează. Pentru dimensiuni cunoscute doar la rulare folosește std::vector.
• Pui un std::array uriaș (milioane de elemente) ca variabilă locală. Stiva este mică, iar programul se poate opri; folosește std::vector.

Comenzi înrudite

• std::vector: Tabloul dinamic din C++: ține elementele unul după altul în memorie și își mărește singur dimensiunea.
• std::to_array: Creează un std::array dintr-un tablou C sau dintr-o listă, cu dimensiunea dedusă automat.
• std::span: O „fereastră” spre elemente consecutive din memorie (vector, array, tablou C), fără copiere și fără să le dețină.
• std::get: Citește elementul unui tuplu, al unei perechi sau al unui std::array după poziție (sau după tip), la compilare.