Default-initialization

Dies ist die Initialisierung, die durchgeführt wird, wenn ein Objekt ohne Initialisierer konstruiert wird.

Syntax

Erklärung

Default-Initialisierung wird in drei Situationen durchgeführt:

Die Auswirkungen der Default-Initialisierung sind:

• wenn T ein (möglicherweise cv-qualifizierter) Nicht-POD (bis C++11) Klassentyp ist, werden die Konstruktoren berücksichtigt und einer Überladungsauflösung mit der leeren Argumentliste unterzogen. Der ausgewählte Konstruktor (welcher einer der Standardkonstruktoren ist) wird aufgerufen, um den Anfangswert für das neue Objekt bereitzustellen;
• wenn T ein Array-Typ ist, wird jedes Element des Arrays standardinitialisiert;
• andernfalls wird keine Initialisierung durchgeführt (siehe Anmerkungen ).

Standardinitialisierung eines const-Objekts

Wenn ein Programm die Standardinitialisierung eines Objekts eines const -qualifizierten Typs T erfordert, muss T ein const-default-constructible Klassentyp oder Array davon sein.

Ein Klassentyp T ist const-default-konstruierbar, wenn die Default-Initialisierung von T einen benutzerdefinierten Konstruktor von T aufrufen würde (nicht von einer Basisklasse geerbt) (seit C++11) oder wenn

jede potenziell konstruierte Basisklasse von T ist const-standardkonstruierbar.

Unbestimmte und fehlerhafte Werte

Wenn eine Auswertung einen unbestimmten Wert erzeugt, ist das Verhalten undefined .

Sonderfälle

Die folgenden Typen sind uninitialized-friendly :

• unsigned char
• char , falls sein zugrundeliegender Typ unsigned char ist

Bei einem unbestimmten oder fehlerhaften (seit C++26) Wert value ist der nicht initialisierte Ergebniswert von value :

• Ein unbestimmter Wert, wenn value ebenfalls ein unbestimmter Wert ist.

Wenn eine Auswertung eval einen undefinierten oder fehlerhaften (seit C++26) Wert value eines initialisierungsfreundlichen Typs erzeugt, ist das Verhalten in den folgenden Fällen wohldefiniert:

• eval ist die Auswertung eines der folgenden Ausdrücke und Operanden:

• Der zweite oder dritte Operand eines Bedingungsausdrucks .
• Der rechte Operand eines Kommaausdrucks .
• Der Operand einer integralen Konvertierung , expliziten Typumwandlung oder static_cast zu einem uninitialisierungsfreundlichen Typ.
• Ein verworfen-wertiger Ausdruck .

In diesem Fall ist das Ergebnis der Operation der uninitialisierte Ergebniswert von value .

• eval ist eine Auswertung des rechten Operanden eines einfachen Zuweisungsoperators , dessen linker Operand ein L-Wert eines uninitialized-friendly Typs ist.

In diesem Fall wird der Wert des Objekts, auf das der linke Operand verweist, durch den nicht initialisierten Ergebniswert von value ersetzt.

• eval ist die Auswertung des Initialisierungsausdrucks bei der Initialisierung eines Objekts eines uninitialized-friendly-Typs.

In diesem Fall wird das Objekt mit dem nicht initialisierten Ergebniswert von value initialisiert.

Die Konvertierung eines unbestimmten Werts eines uninitialisierungsfreundlichen Typs erzeugt einen unbestimmten Wert.

// Fall 1: Nicht initialisierte Objekte mit dynamischer Speicherdauer
// Alle C++-Versionen: unbestimmter Wert + undefiniertes Verhalten
int f(bool b)
{
    unsigned char* c = new unsigned char;
    unsigned char d = *c; // OK, "d" hat einen unbestimmten Wert
    int e = d;            // undefiniertes Verhalten
    return b ? d : 0;     // undefiniertes Verhalten wenn "b" true ist
}
// Fall 2: Nicht initialisierte Objekte mit automatischer Speicherdauer
// bis C++26: unbestimmter Wert + undefiniertes Verhalten
// seit C++26: fehlerhafter Wert + fehlerhaftes Verhalten
int g(bool b)
{
    unsigned char c;     // "c" hat einen unbestimmten/fehlerhaften Wert
    unsigned char d = c; // kein undefiniertes/fehlerhaftes Verhalten,
                         // aber "d" hat einen unbestimmten/fehlerhaften Wert
    assert(c == d);      // gilt, aber beide Integralpromotionen haben
                         // undefiniertes/fehlerhaftes Verhalten
    int e = d;           // undefiniertes/fehlerhaftes Verhalten
    return b ? d : 0;    // undefiniertes/fehlerhaftes Verhalten wenn "b" true ist
}
// Gleich wie Fall 2
void h()
{
    int d1, d2;  // "d1" und "d2" haben unbestimmte/fehlerhafte Werte
    int e1 = d1; // undefiniertes/fehlerhaftes Verhalten
    int e2 = d1; // undefiniertes/fehlerhaftes Verhalten
    assert(e1 == e2); // gilt
    assert(e1 == d1); // gilt, undefiniertes/fehlerhaftes Verhalten
    assert(e2 == d1); // gilt, undefiniertes/fehlerhaftes Verhalten
    // kein undefiniertes/fehlerhaftes Verhalten,
    // aber "d2" hat einen unbestimmten/fehlerhaften Wert
    std::memcpy(&d2, &d1, sizeof(int));
    assert(e1 == d2); // gilt, undefiniertes/fehlerhaftes Verhalten
    assert(e2 == d2); // gilt, undefiniertes/fehlerhaftes Verhalten
}

Hinweise

Referenzen und konstante skalare Objekte können nicht standardmäßig initialisiert werden.

Beispiel

#include <string>
struct T1 { int mem; };
struct T2
{
    int mem;
    T2() {} // "mem" ist nicht in der Initialisierungsliste
};
int n; // statisch Nicht-Klasse, eine zweiphasige Initialisierung wird durchgeführt:
       // 1) Null-Initialisierung initialisiert n auf Null
       // 2) Standard-Initialisierung macht nichts, lässt n bei Null
int main()
{
    [[maybe_unused]]
    int n;            // Nicht-Klasse, der Wert ist unbestimmt
    std::string s;    // Klasse, ruft Standardkonstruktor auf, der Wert ist ""
    std::string a[2]; // Array, standardinitialisiert die Elemente, der Wert ist {"", ""}
//  int& r;           // Fehler: eine Referenz
//  const int n;      // Fehler: eine const Nicht-Klasse
//  const T1 t1;      // Fehler: const Klasse mit implizitem Standardkonstruktor
    [[maybe_unused]]
    T1 t1;            // Klasse, ruft impliziten Standardkonstruktor auf
    const T2 t2;      // const Klasse, ruft den benutzerdefinierten Standardkonstruktor auf
                      // t2.mem ist standardinitialisiert
}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch

• Konvertierungskonstruktor
• Standardkonstruktor
• explicit
• Initialisierung
  • Aggregatinitialisierung
  • Konstanteninitialisierung
  • Kopierinitialisierung
  • Direktinitialisierung
  • Listeninitialisierung
  • Referenzinitialisierung
  • Wertinitialisierung
  • Nullinitialisierung
• new