Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Inizializzazione per valore e parentesi graffe vuote `{}` in C++23

Le parentesi graffe vuote non indicano sempre un’inizializzazione per valore. Il tipo stabilisce se inizializzare uno scalare, chiamare un costruttore o applicare le regole degli aggregati.

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

Sintassi

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, T object{}; è un’inizializzazione diretta con lista vuota. T object = {}; è un’inizializzazione per copia con lista, non un’assegnazione. Il tipo determina la regola successiva: int count{}; e const char* next{}; usano l’inizializzazione per valore. In questi casi l’inizializzazione a zero produce rispettivamente 0 e un puntatore nullo, la cui rappresentazione non deve necessariamente avere tutti i bit a zero.

Result result{}; e char ready[32]{}; usano l’inizializzazione di aggregato. In un aggregato che non è un’unione, un elemento omesso usa il proprio inizializzatore di membro predefinito, se presente; altrimenti, se non è un riferimento, viene inizializzato per copia da {}. Omettere un riferimento senza inizializzatore è un errore. Quindi result.count vale 0, result.next è un puntatore nullo e ogni elemento di ready vale \0.

Quando una classe viene inizializzata per valore, l’oggetto viene inizializzato per default. L’inizializzazione a zero la precede solo se il costruttore selezionato non è fornito dall’utente. Dopo struct C { int n; C() {} }; C c{};, il membro c.n dell’oggetto locale resta quindi non inizializzato.

In const char* input, * dichiara un puntatore; const qualifica i caratteri, non il puntatore. Nella dichiarazione locale char scratch[32];, [32] dichiara un array di 32 caratteri i cui elementi non sono inizializzati. Leggi solo gli elementi già scritti. Prima di usare il buffer come stringa C, scrivi anche un \0 finale entro i limiti dell’array.

Esempi

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

Risultato

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

Il programma scrive in `scratch[0]` prima di leggerlo e stampa un solo carattere, non il buffer come stringa. Il confronto su `ready[31]` controlla l’ultimo carattere; `result.next == nullptr` controlla il valore del puntatore senza dereferenziarlo.

Lezioni correlate

  • C++ · Lezione 47 · Avanzato · Versione: 3

Fonti