WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Der Array-Deklarator (`[]`) in C++

Der Deklarator `[]` bildet einen eingebauten Array-Typ. Die Elementanzahl kann Teil des Typs sein, wird aber durch die Array-Schreibweise eines Funktionsparameters nicht übergeben.

Version: 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] deklariert [] ein Array mit N zusammenhängend gespeicherten Elementen vom Typ T. Ein explizites N muss ein konvertierter konstanter Ausdruck vom Typ std::size_t mit einem Wert größer als null sein. Arrays mit erst zur Laufzeit bestimmter Größe sind in diesem Deklarator eine Compiler-Erweiterung und kein Bestandteil von ISO C++23. Im Ausdruck a[i] dienen die Klammern dem Indexzugriff, nicht der Deklaration. Zugriffe außerhalb der Indizes 0 bis N - 1 haben undefiniertes Verhalten.

In int a[]{1, 2} ergibt sich die Elementanzahl aus dem Initialisierer. Dagegen deklariert extern int a[]; ohne eine frühere Deklaration mit Größenangabe einen unvollständigen Array-Typ, auf den sizeof nicht angewendet werden kann. Ein lokales char buf[32]; mit automatischer Speicherdauer lässt die Elemente uninitialisiert: Beschreibe sie vor dem Lesen. In char buf[32]{}; setzt die Aggregatinitialisierung jedes Element auf null. Ein Member char label[8]; liegt im Objekt selbst; als C-Zeichenkette benötigt es ein Element für das abschließende \0.

In T* slots[N] sind die Elemente Zeiger; in T (*p)[N] ist p selbst ein Zeiger auf ein ganzes Array. T (&r)[N] ist eine Lvalue-Referenz auf ein ganzes Array. In T* p = a; wird das Array implizit in einen Zeiger auf sein erstes Element umgewandelt, ohne Längeninformation. Bei einem vollständigen Array liefert sizeof a die Größe des gesamten Arrays in Bytes. Bei T grid[R][C] ist das erste Element eine Zeile vom Typ T[C]; die Umwandlung ergibt daher T (*)[C], nicht T**.

Bei der Parameterdeklaration wird void f(const T a[N]); zu void f(const T* a); angepasst. Beide Schreibweisen deklarieren dieselbe Funktion und keine Überladungen; N erzwingt keine Mindestlänge, und const gilt für die Elemente. Diese Regel ist von der Umwandlung des Arguments beim Aufruf zu unterscheiden. Übergib den Zeiger mit einer gültigen Anzahl zugänglicher Elemente oder verwende eine Array-Referenz als Parameter, um die Anzahl im Typ zu behalten. Greife nach Ende der Lebensdauer des Arrays nicht mehr über einen solchen Zeiger oder eine solche Referenz auf seine Elemente zu.

Beispiele

#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';
}

Ergebnis

2 7 1

`extent` leitet die Anzahl der Datensätze aus dem Array-Typ ab. `sum` erhält einen Zeiger und die Anzahl separat. Die Ausgabe `2 7 1` steht für zwei Datensätze, die Summe 7 und einen wahren Vergleich des ersten Elements von `buffer` mit dem Nullzeichen.

Zugehörige Lektionen

  • C++ · Lektion 47 · Fortgeschritten · Version: 3
  • C++ · Lektion 53 · Fortgeschritten · Version: 3
  • C++ · Lektion 56 · Fortgeschritten · Version: 3
  • C++ · Lektion 58 · Fortgeschritten · Version: 3

Quellen