Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Le déclarateur de tableau (`[]`) en C++

Le déclarateur `[]` forme un type tableau natif. Le nombre d’éléments peut faire partie du type du tableau, mais la notation tableau d’un paramètre ne transmet pas ce nombre.

Version : 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)

Dans T a[N], le déclarateur [] déclare N éléments contigus de type T. Un N explicite doit être une expression constante convertie de type std::size_t, de valeur strictement positive. Dans ce déclarateur, une taille déterminée à l’exécution relève d’une extension du compilateur, pas d’ISO C++23. Dans l’expression a[i], les crochets servent à l’indexation, pas à la déclaration. Tout accès en dehors des indices 0 à N - 1 entraîne un comportement indéfini.

Dans int a[]{1, 2}, l’initialiseur fixe le nombre d’éléments. À l’inverse, extern int a[];, sans déclaration antérieure qui donne la taille, déclare un type tableau incomplet auquel sizeof ne peut pas s’appliquer. Un char buf[32]; local à durée de stockage automatique laisse les éléments non initialisés : écrivez-les avant de les lire. Dans char buf[32]{};, l’initialisation d’agrégat donne la valeur zéro à chaque élément. Un membre char label[8]; est stocké dans l’objet lui-même ; s’il contient une chaîne C, un élément doit contenir le \0 final.

Dans T* slots[N], les éléments sont des pointeurs ; dans T (*p)[N], p pointe vers un tableau entier. T (&r)[N] est une référence lvalue à un tableau entier. Dans T* p = a;, le tableau est implicitement converti en pointeur vers son premier élément, sans information de longueur. Pour un tableau de type complet, sizeof a donne la taille en octets du tableau entier. Avec T grid[R][C], le premier élément est une ligne de type T[C] : la conversion donne donc T (*)[C], et non T**.

Dans une déclaration de paramètre, void f(const T a[N]); est ajusté en void f(const T* a);. Les deux écritures déclarent la même fonction, pas deux surcharges ; N n’impose aucune longueur minimale et const s’applique aux éléments. Cette règle est distincte de la conversion d’un argument lors de l’appel. Passez le pointeur avec un nombre valide d’éléments accessibles, ou utilisez un paramètre de type référence à un tableau pour garder la taille dans le type. N’accédez plus aux éléments via un tel pointeur ou une telle référence après la fin de vie du tableau.

Exemples

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

Résultat

2 7 1

`extent` déduit le nombre d’enregistrements du type du tableau. `sum` reçoit un pointeur et un nombre séparé. La sortie `2 7 1` indique deux enregistrements, une somme de 7 et une comparaison vraie du premier élément de `buffer` avec le caractère nul.

Leçons associées

  • C++ · Leçon 47 · Avancé · Version : 3
  • C++ · Leçon 53 · Avancé · Version : 3
  • C++ · Leçon 56 · Avancé · Version : 3
  • C++ · Leçon 58 · Avancé · Version : 3

Sources