List-initialization (since C++11)

Initialisiert ein Objekt aus einer geschweiften Klammer-Initialisierungsliste .

Syntax

Direkte Listeninitialisierung

Copy-Listeninitialisierung

Die Listeninitialisierung wird in den folgenden Situationen durchgeführt:

• direkte Listeninitialisierung (sowohl explizite als auch nicht-explizite Konstruktoren werden berücksichtigt)

• Copy-List-Initialisierung (sowohl explizite als auch nicht-explizite Konstruktoren werden berücksichtigt, aber nur nicht-explizite Konstruktoren können aufgerufen werden)

Erklärung

Die Auswirkungen der Listeninitialisierung eines Objekts vom Typ (möglicherweise cv-qualifiziert) T sind:

• Wenn T eine Aggregatklasse ist und die geschweifte Klammer-Initialisierungsliste , die keine designated initializer list enthält, (seit C++20) eine einzelne Initialisierungsklausel desselben oder abgeleiteten Typs (möglicherweise cv-qualifiziert) enthält, wird das Objekt aus dieser Initialisierungsklausel initialisiert (durch Copy-Initialisierung für Copy-List-Initialisierung oder durch Direct-Initialisierung für Direct-List-Initialisierung).
• Andernfalls, wenn T ein Zeichenarray ist und die geschweifte Klammer-Initialisierungsliste eine einzelne Initialisierungsklausel enthält, die ein Zeichenkettenliteral mit passendem Typ ist, wird das Array wie üblich vom Zeichenkettenliteral initialisiert .

• Andernfalls, falls T ein Aggregattyp ist, wird Aggregatinitialisierung durchgeführt.

• Andernfalls, wenn die geschweifte Klammer-Initialisierungsliste leer ist und T ein Klassentyp mit einem Standardkonstruktor ist, wird Wertinitialisierung durchgeführt.

• Andernfalls, falls T eine Spezialisierung von std::initializer_list ist, wird das Objekt wie unten beschrieben initialisiert.

• Andernfalls, wenn T ein Klassentyp ist, werden die Konstruktoren von T in zwei Phasen betrachtet:

• Alle Konstruktoren, die std::initializer_list als einzigen Argument annehmen, oder als erstes Argument, falls die restlichen Argumente Standardwerte haben, werden geprüft und durch overload resolution gegen ein einzelnes Argument vom Typ std::initializer_list abgeglichen.

• Wenn die vorherige Stufe keine Übereinstimmung ergibt, nehmen alle Konstruktoren von T an der Überlagerungsauflösung gegenüber der Menge der Argumente teil, die aus den Initialisierer-Klauseln der geschweiften Initialisiererliste besteht, mit der Einschränkung, dass nur nicht-verengende Konvertierungen erlaubt sind. Wenn diese Stufe einen expliziten Konstruktor als beste Übereinstimmung für eine Copy-List-Initialisierung ergibt, schlägt die Kompilierung fehl (beachte, bei einfacher Copy-Initialisierung werden explizite Konstruktoren überhaupt nicht berücksichtigt).

• Andernfalls (wenn T kein Klassentyp ist), falls die geschweifte Initialisierungsliste nur einen Initialisierungsabschnitt enthält und entweder T kein Referenztyp ist oder ein Referenztyp, dessen referenzierter Typ derselbe wie oder eine Basisklasse des Typs des Initialisierungsabschnitts ist, wird T direkt initialisiert (bei direkter Listeninitialisierung) oder kopierinitialisiert (bei Kopierlisteninitialisierung), außer dass einschränkende Konvertierungen nicht erlaubt sind.

• Andernfalls, wenn T ein Referenztyp ist, der nicht mit dem Typ des Initialisierer-Ausdrucks kompatibel ist:

• Andernfalls, wenn die geschweifte Klammer-Initialisiererliste keine Initialisierer-Klausel hat, T wird value-initialized .

Listeninitialisierung von std::initializer_list

Ein Objekt vom Typ std:: initializer_list < E > wird aus einer Initialisierungsliste konstruiert, als ob der Compiler einen materialisierten (seit C++17) Prvalue vom Typ "Array von N const E " erzeugen würde, wobei N die Anzahl der Initialisierungsclauseln in der Initialisierungsliste ist; dies wird als Backing Array der Initialisierungsliste bezeichnet.

Jedes Element des zugrundeliegenden Arrays wird copy-initialisiert mit dem entsprechenden Initialisierer-Ausdruck der Initialisiererliste, und das std:: initializer_list < E > -Objekt wird so konstruiert, dass es auf dieses Array verweist. Ein für den Kopiervorgang ausgewählter Konstruktor oder eine Konvertierungsfunktion muss zugänglich im Kontext der Initialisiererliste sein. Wenn eine einschränkende Konvertierung zur Initialisierung eines der Elemente erforderlich ist, ist das Programm fehlerhaft.

Das zugrundeliegende Array hat die gleiche Lebensdauer wie jedes andere temporäre Objekt , außer dass die Initialisierung eines std::initializer_list -Objekts aus dem zugrundeliegenden Array die Lebensdauer des Arrays genau wie das Binden einer Referenz an ein temporäres Objekt verlängert.

void f(std::initializer_list<double> il);
void g(float x)
{
   f({1, x, 3});
}
void h()
{
   f({1, 2, 3});
}
struct A { mutable int i; };
void q(std::initializer_list<A>);
void r()
{
    q({A{1}, A{2}, A{3}});
}
// Die obige Initialisierung wird in etwa äquivalent zu unten implementiert,
// unter der Annahme, dass der Compiler ein initializer_list-Objekt mit einem Paar von
// Zeigern konstruieren kann, und mit dem Verständnis, dass `__b` den Aufruf von `f` nicht überlebt.
void g(float x)
{
    const double __a[3] = {double{1}, double{x}, double{3}}; // Backing-Array
    f(std::initializer_list<double>(__a, __a + 3));
}
void h()
{
    static constexpr double __b[3] =
        {double{1}, double{2}, double{3}}; // Backing-Array
    f(std::initializer_list<double>(__b, __b + 3));
}
void r()
{
    const A __c[3] = {A{1}, A{2}, A{3}}; // Backing-Array
    q(std::initializer_list<A>(__c, __c + 3));
}

Ob alle zugrundeliegenden Arrays unterschiedlich sind (d. h. in nicht-überlappenden Objekten gespeichert sind), ist nicht spezifiziert:

bool fun(std::initializer_list<int> il1, std::initializer_list<int> il2)
{
    return il2.begin() == il1.begin() + 1;
}
bool overlapping = fun({1, 2, 3}, {2, 3, 4}); // das Ergebnis ist nicht spezifiziert:
                                              // die zugrundeliegenden Arrays können
                                              // Speicher innerhalb von {1, 2, 3, 4} teilen

Einschränkende Konvertierungen

Die Listeninitialisierung beschränkt die zulässigen impliziten Konvertierungen , indem folgende verboten werden:

• Umwandlung von einem Gleitkommatyp in einen Ganzzahltyp

• Konvertierung von einem Gleitkommatyp T zu einem anderen Gleitkommatyp, dessen floating-point conversion rank weder größer als noch gleich dem von T ist, außer wenn das Konvertierungsergebnis ein constant expression ist und eine der folgenden Bedingungen erfüllt ist:
  • Der konvertierte Wert ist endlich und die Konvertierung führt nicht zu einem Überlauf.
  • Die Werte vor und nach der Konvertierung sind nicht endlich.

• Konvertierung von einem Ganzzahltyp zu einem Gleitkommatyp, außer wenn die Quelle ein konstanter Ausdruck ist, dessen Wert exakt im Zieltyp gespeichert werden kann

• Konvertierung von einem Integer- oder unbegrenzten Enumerationstyp zu einem Integer-Typ, der nicht alle Werte des Originals darstellen kann, außer wenn
  • die Quelle ein Bitfeld ist, dessen Breite w geringer ist als die seines Typs (oder, für einen Enumerationstyp , seines zugrundeliegenden Typs) und der Zieltyp alle Werte eines hypothetischen erweiterten Integer-Typs mit Breite w und mit der gleichen Vorzeichenbehaftung wie der Originaltyp darstellen kann, oder
  • die Quelle ein konstanter Ausdruck ist, dessen Wert exakt im Zieltyp gespeichert werden kann

• Umwandlung von einem Zeigertyp oder Zeiger-auf-Member-Typ zu bool

Hinweise

Jeder Initialisierer-Ausdruck ist sequenced before jedem Initialisierer-Ausdruck, der ihm in der geschweiften Initialisiererliste folgt. Dies steht im Gegensatz zu den Argumenten eines function call expression , die unsequenced (until C++17) indeterminately sequenced (since C++17) sind.

Eine in geschweiften Klammern eingeschlossene Initialisierungsliste ist kein Ausdruck und hat daher keinen Typ, z.B. decltype ( { 1 , 2 } ) ist fehlerhaft. Das Fehlen eines Typs bedeutet, dass die Template-Typableitung keinen Typ ableiten kann, der einer in geschweiften Klammern eingeschlossenen Initialisierungsliste entspricht, daher ist bei der Deklaration template < class T > void f ( T ) ; der Ausdruck f ( { 1 , 2 , 3 } ) fehlerhaft. Allerdings kann der Template-Parameter anderweitig abgeleitet werden, wie im Fall von std:: vector < int > v ( std:: istream_iterator < int > ( std:: cin ) , { } ) , wo der Iteratortyp durch das erste Argument abgeleitet wird, aber auch in der zweiten Parameterposition verwendet wird. Eine spezielle Ausnahme wird für Typableitung mit dem Schlüsselwort auto gemacht, das jede in geschweiften Klammern eingeschlossene Initialisierungsliste in der Copy-List-Initialisierung als std::initializer_list ableitet.

Auch weil eine in geschweifte Klammern eingeschlossene Initialisierungsliste keinen Typ hat, gelten spezielle Regeln für Overload Resolution , wenn sie als Argument für einen überladenen Funktionsaufruf verwendet wird.

Aggregate führen Copy-/Move-Initialisierung direkt aus einer geschweiften Initialisierungsliste mit einer einzelnen Initialisierungsklausel desselben Typs durch, aber Nicht-Aggregate berücksichtigen zuerst std::initializer_list Konstruktoren:

struct X {}; // Aggregat
struct Q     // Nicht-Aggregat
{
    Q() = default;
    Q(Q const&) = default;
    Q(std::initializer_list<Q>) {}
};
int main()
{
    X x;
    X x2 = X{x}; // Copy-Konstruktor (keine Aggregat-Initialisierung)
    Q q;
    Q q2 = Q{q}; // Initializer-List-Konstruktor (kein Copy-Konstruktor)
}

Einige Compiler (z.B. gcc 10) betrachten nur die Konvertierung von einem Zeiger oder einem Zeiger-auf-Mitglied zu bool als Einengung im C++20-Modus.

Beispiel

#include <iostream>
#include <map>
#include <string>
#include <vector>
struct Foo
{
    std::vector<int> mem = {1, 2, 3}; // Listeninitialisierung eines nicht-statischen Members
    std::vector<int> mem2;
    Foo() : mem2{-1, -2, -3} {} // Listeninitialisierung eines Members im Konstruktor
};
std::pair<std::string, std::string> f(std::pair<std::string, std::string> p)
{
    return {p.second, p.first}; // Listeninitialisierung in return-Anweisung
}
int main()
{
    int n0{};  // Wertinitialisierung (auf Null)
    int n1{1}; // direkte Listeninitialisierung
    std::string s1{'a', 'b', 'c', 'd'}; // Initializer-List-Konstruktoraufruf
    std::string s2{s1, 2, 2};           // regulärer Konstruktoraufruf
    std::string s3{0x61, 'a'}; // Initializer-List-Konstruktor wird (int, char) vorgezogen
    int n2 = {1}; // Kopier-Listeninitialisierung
    double d = double{1.2}; // Listeninitialisierung eines PR-Werts, dann Kopierinitialisierung
    auto s4 = std::string{"HelloWorld"}; // wie oben, kein temporäres Objekt
                                         // erzeugt seit C++17
    std::map<int, std::string> m = // verschachtelte Listeninitialisierung
    {
        {1, "a"},
        {2, {'a', 'b', 'c'}},
        {3, s1}
    };
    std::cout << f({"hello", "world"}).first // Listeninitialisierung im Funktionsaufruf
              << '\n';
    const int (&ar)[2] = {1, 2}; // bindet eine Lvalue-Referenz an ein temporäres Array
    int&& r1 = {1}; // bindet eine Rvalue-Referenz an einen temporären int
//  int& r2 = {2}; // Fehler: kann Rvalue nicht an nicht-konstante Lvalue-Referenz binden
//  int bad{1.0}; // Fehler: einschränkende Konvertierung
    unsigned char uc1{10}; // okay
//  unsigned char uc2{-1}; // Fehler: einschränkende Konvertierung
    Foo f;
    std::cout << n0 << ' ' << n1 << ' ' << n2 << '\n'
              << s1 << ' ' << s2 << ' ' << s3 << '\n';
    for (auto p : m)
        std::cout << p.first << ' ' << p.second << '\n';
    for (auto n : f.mem)
        std::cout << n << ' ';
    for (auto n : f.mem2)
        std::cout << n << ' ';
    std::cout << '\n';
    [](...){}(d, ar, r1, uc1); // hat Effekt von [[maybe_unused]]
}

world
0 1 1
abcd cd aa
1 a
2 abc
3 abcd
1 2 3 -1 -2 -3

Fehlerberichte

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

Siehe auch

• Konstruktor
• Konvertierungskonstruktor
• Kopierzuweisung
• Kopierkonstruktor
• Kopierauslassung
• Standardkonstruktor
• explicit
• Initialisierung
  • Aggregatinitialisierung
  • Konstanteninitialisierung
  • Kopierinitialisierung
  • Direkte Initialisierung
  • Referenzinitialisierung
  • Wertinitialisierung
  • Nullinitialisierung
• Verschiebezuweisung
• Verschiebekonstruktor
• new