CKTIS / C++
De arraydeclarator (`[]`) in C++
De declarator `[]` vormt een ingebouwd arraytype. Het aantal elementen kan deel uitmaken van het type, maar arraynotatie in een parameter geeft dat aantal niet door.
Versie: ISO C++23; implementation support may vary
Syntax
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)In T a[N] declareert [] een array met N aaneengesloten elementen van type T. Een expliciete N moet een geconverteerde constante expressie van type std::size_t zijn, met een waarde groter dan nul. Arrays waarvan de grootte pas tijdens uitvoering wordt bepaald zijn in deze declarator een compileruitbreiding, geen onderdeel van ISO C++23. In de expressie a[i] betekenen de haken indexering, geen declaratie. Toegang buiten de indices 0 tot en met N - 1 leidt tot ongedefinieerd gedrag.
In int a[]{1, 2} bepaalt de initializer het aantal elementen. Daarentegen declareert extern int a[]; zonder eerdere declaratie die de grootte opgeeft een incompleet arraytype waarop sizeof niet kan worden toegepast. Een lokale char buf[32]; met automatische opslagduur laat de elementen ongeïnitialiseerd: schrijf ze voordat je ze leest. In char buf[32]{}; geeft aggregaatinitialisatie elk element de waarde nul. Een lid char label[8]; is onderdeel van het object zelf; bij gebruik als C-tekenreeks moet één element de afsluitende \0 bevatten.
In T* slots[N] zijn de elementen pointers; in T (*p)[N] wijst p zelf naar een hele array. T (&r)[N] is een lvalue-referentie naar een hele array. In T* p = a; wordt de array impliciet omgezet in een pointer naar het eerste element, zonder lengte-informatie. Voor een compleet arraytype geeft sizeof a de grootte van de hele array in bytes. Bij T grid[R][C] is het eerste element een rij van type T[C], dus de conversie levert T (*)[C] op, niet T**.
Bij een parameterdeclaratie wordt void f(const T a[N]); aangepast tot void f(const T* a);. Beide schrijfwijzen declareren dezelfde functie, geen twee overloads; N dwingt geen minimumlengte af, en const geldt voor de elementen. Deze regel staat los van de conversie van een argument bij de aanroep. Geef de pointer door met een geldig aantal toegankelijke elementen, of gebruik een arrayreferentie als parameter om het aantal in het type te behouden. Lees of schrijf geen elementen meer via zo’n pointer of referentie nadat de levensduur van de array is geëindigd.
Voorbeelden
#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';
}
Resultaat
2 7 1
`extent` leidt het aantal records af uit het arraytype. `sum` krijgt een pointer en een afzonderlijk aantal. De uitvoer `2 7 1` betekent twee records, een som van 7 en dat het eerste element van `buffer` gelijk is aan het nulkarakter.
Gerelateerde lessen
- C++ · Les 47 · Gevorderd · Versie: 3
- C++ · Les 53 · Gevorderd · Versie: 3
- C++ · Les 56 · Gevorderd · Versie: 3
- C++ · Les 58 · Gevorderd · Versie: 3
Bronnen
- Arrays [dcl.array]
- Aggregate initialization [dcl.init.aggr]
- Initializers: General [dcl.init.general]
- Character arrays [dcl.init.string]
- Subscripting [expr.sub]
- Additive operators [expr.add]
- Array-to-pointer conversion [conv.array]
- Sizeof [expr.sizeof]
- Functions [dcl.fct]
- Lifetime [basic.life]
- N4950 — Working Draft, Standard for Programming Language C++