Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Deklarátor pole (`[]`) v C++

Deklarátor `[]` vytváří vestavěný typ pole. Počet prvků může být součástí typu pole, ale zápis parametru ve tvaru pole tento počet nepředává.

Verze: ISO C++23; implementation support may vary

Syntaxe

T a[N];                  // array of N elements of type T
T a[] = {v1, v2};         // bound inferred as 2 in this definition
extern T a[];             // unknown bound if no prior declaration supplies it
T grid[R][C];             // R elements, each an array of C elements
T* slots[N];              // array of N pointers to T
T (*p)[N] = &a;           // pointer to the whole array
T (&r)[N] = a;            // lvalue reference to the whole array
void f(const T a[N]);    // adjusted to void f(const T* a)

V T a[N] deklarátor [] deklaruje N prvků typu T uložených souvisle v paměti. Výslovně uvedené N musí být převedený konstantní výraz typu std::size_t s hodnotou větší než nula. Pole s velikostí určenou až za běhu jsou v tomto deklarátoru rozšířením překladače, nikoli součástí ISO C++23. Ve výrazu a[i] hranaté závorky znamenají indexování, nikoli deklaraci. Přístup mimo indexy 0 až N - 1 má nedefinované chování.

V int a[]{1, 2} určuje počet prvků inicializátor. Naproti tomu extern int a[]; bez dřívější deklarace s uvedenou velikostí deklaruje neúplný typ pole, na který nelze použít sizeof. Lokální char buf[32]; s automatickou dobou uložení ponechá prvky neinicializované: před čtením je zapiš. V char buf[32]{}; inicializace agregátu nastaví každý prvek na nulu. Člen char label[8]; je uložen přímo v objektu; při použití jako řetězec jazyka C musí jeden prvek obsahovat koncové \0.

V T* slots[N] jsou prvky ukazatele; v T (*p)[N] je p ukazatel na celé pole. T (&r)[N] je lvalue reference na celé pole. V T* p = a; se pole implicitně převede na ukazatel na první prvek bez informace o délce. U pole úplného typu vrací sizeof a velikost celého pole v bajtech. U T grid[R][C] je první prvek řádek typu T[C], takže převod dává T (*)[C], nikoli T**.

Při deklaraci parametru se void f(const T a[N]); upraví na void f(const T* a);. Oba zápisy deklarují tutéž funkci, nikoli dvě přetížení; N nevynucuje minimální délku a const se vztahuje na prvky. Toto pravidlo je odlišné od převodu argumentu při volání. Předej ukazatel s platným počtem dostupných prvků nebo použij parametr typu reference na pole, aby počet zůstal součástí typu. Po skončení životnosti pole přes takový ukazatel ani referenci k jeho prvkům nepřistupuj.

Příklady

#include <cstddef>
#include <iostream>
#include <type_traits>

struct Record {
    char label[8];
    int value;
};

int sum(const Record items[2], std::size_t count) {
    static_assert(std::is_same_v<decltype(items), const Record*>);
    int total = 0;
    for (std::size_t i = 0; i < count; ++i) {
        total += items[i].value;
    }
    return total;
}

template <std::size_t N>
constexpr std::size_t extent(const Record (&)[N]) {
    return N;
}

int main() {
    const Record records[]{{"A", 3}, {"B", 4}};
    char32_t buffer[4]{};
    const auto count = extent(records);
    std::cout << count << ' ' << sum(records, count) << ' '
              << (buffer[0] == U'\0') << '\n';
}

Výsledek

2 7 1

`extent` odvodí počet záznamů z typu pole. `sum` dostane ukazatel a počet zvlášť. Výstup `2 7 1` znamená dva záznamy, součet 7 a shodu prvního prvku `buffer` s nulovým znakem.

Související lekce

  • C++ · Lekce 47 · Pokročilá · Verze: 3
  • C++ · Lekce 53 · Pokročilá · Verze: 3
  • C++ · Lekce 56 · Pokročilá · Verze: 3
  • C++ · Lekce 58 · Pokročilá · Verze: 3

Zdroje