KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Waarde-initialisatie en lege accolades `{}` in C++23

Lege accolades betekenen niet altijd waarde-initialisatie. Het type bepaalt of een scalair wordt geïnitialiseerd, een constructor wordt aangeroepen of de regels voor aggregaten gelden.

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

Syntax

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.

In C++23 is T object{}; directe lijstinitialisatie met een lege lijst. T object = {}; is kopie-initialisatie met een lijst, geen toewijzing. Het type bepaalt de vervolgregel: int count{}; en const char* next{}; gebruiken waarde-initialisatie. Nulinitialisatie levert hier respectievelijk 0 en een nullpointer op. De representatie van een nullpointer hoeft niet uit alleen nulbits te bestaan.

Result result{}; en char ready[32]{}; gebruiken aggregaatinitialisatie. Bij een aggregaat dat geen union is, gebruikt een weggelaten element zijn standaardlidinitialisator als die er is. Anders wordt een element dat geen referentie is via kopie-initialisatie uit {} geïnitialiseerd. Een weggelaten referentie zonder initialisator is een fout. Daarom is result.count gelijk aan 0, is result.next een nullpointer en is elk element van ready gelijk aan \0.

Bij waarde-initialisatie van een klasse wordt het object standaard geïnitialiseerd. Nulinitialisatie gaat daar alleen aan vooraf als de geselecteerde constructor niet door de gebruiker is geleverd. Na struct C { int n; C() {} }; C c{}; blijft het lid c.n van het lokale object dus ongeïnitialiseerd.

In const char* input declareert * een pointer; const geldt voor de tekens, niet voor de pointer. In de lokale declaratie char scratch[32]; declareert [32] een array van 32 tekens waarvan de elementen niet worden geïnitialiseerd. Lees alleen elementen waarnaar je al geschreven hebt. Schrijf ook een afsluitende \0 binnen de arraygrenzen voordat je de buffer als C-string gebruikt.

Voorbeelden

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

Resultaat

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

Het programma schrijft naar `scratch[0]` voordat het dit element leest en drukt één teken af, niet de buffer als tekenreeks. De vergelijking met `ready[31]` controleert het laatste teken; `result.next == nullptr` controleert de pointerwaarde zonder de pointer te derefereren.

Gerelateerde lessen

  • C++ · Les 47 · Gevorderd · Versie: 3

Bronnen