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

CKTIS / C++

Initialisation par valeur et accolades vides `{}` en C++23

Les accolades vides ne signifient pas toujours initialisation par valeur. Le type détermine si un scalaire est initialisé, si un constructeur est appelé ou si les règles des agrégats s’appliquent.

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

Syntaxe

T object{};          // Direct-list-initialization; the type determines the rule.
T object = {};       // Copy-list-initialization, not assignment.
int count{};         // Value-initialization: 0.
const char* next{};  // Value-initialization: null pointer.
char scratch[32];    // Default-initialization; automatic char elements are not initialized.
char ready[32]{};    // Aggregate initialization: all 32 elements are '\0'.
Result result{};     // Aggregate initialization when Result is the aggregate below.

En C++23, T object{}; est une initialisation directe par liste avec une liste vide. T object = {}; est une initialisation par copie avec une liste, et non une affectation. Le type détermine la suite : int count{}; et const char* next{}; sont des cas d’initialisation par valeur. L’initialisation à zéro donne ici respectivement 0 et un pointeur nul. La représentation d’un pointeur nul n’est pas nécessairement composée uniquement de bits à zéro.

Result result{}; et char ready[32]{}; relèvent de l’initialisation d’agrégat. Dans un agrégat qui n’est pas une union, un élément omis utilise son initialiseur de membre par défaut s’il en possède un ; sinon, s’il n’est pas une référence, il est initialisé par copie à partir de {}. Omettre une référence sans initialiseur est une erreur. Ainsi, result.count vaut 0, result.next est un pointeur nul et chaque élément de ready vaut \0.

Lors de l’initialisation par valeur d’une classe, l’objet est initialisé par défaut. Il est auparavant initialisé à zéro uniquement si le constructeur sélectionné n’est pas fourni par l’utilisateur. Après struct C { int n; C() {} }; C c{};, le membre c.n de l’objet local reste donc non initialisé.

Dans const char* input, * déclare un pointeur ; const qualifie les caractères, pas le pointeur. Dans la déclaration locale char scratch[32];, [32] déclare un tableau de 32 caractères dont les éléments ne sont pas initialisés. Ne lis que les éléments déjà écrits. Avant d’utiliser le tampon comme chaîne C, écris aussi un \0 final dans les limites du tableau.

Exemples

#include <iostream>

struct Result {
    int count;
    const char* next;
};

int main() {
    const char* input = "A";
    char scratch[32];
    char ready[32]{};
    int count{};
    Result result{};

    scratch[0] = input[0];
    std::cout << "copied: " << scratch[0] << '\n';
    std::cout << "ready[31] is null character: " << (ready[31] == '\0') << '\n';
    std::cout << "count: " << count << '\n';
    std::cout << "result: " << result.count << ", null pointer: "
              << (result.next == nullptr) << '\n';
}

Résultat

copied: A
ready[31] is null character: 1
count: 0
result: 0, null pointer: 1

Le programme écrit dans `scratch[0]` avant de le lire et affiche un seul caractère, pas le tampon comme chaîne. La comparaison sur `ready[31]` vérifie le dernier caractère ; `result.next == nullptr` vérifie la valeur du pointeur sans le déréférencer.

Leçons associées

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

Sources