list initialization

This page has been machine-translated from the English version of the wiki using Google Translate. The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. Click here for the English version of this page

[Bearbeiten] Syntax

[Bearbeiten] Erklärung

• Wenn die braced-init-Liste ist leer und T ist eine Klasse-Typ mit einem Standardkonstruktor wird Value-Initialisierung durchgeführt .

  Original:

  If the braced-init-list is empty and T is a class type with a default constructor, Value-Initialisierung is performed.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Andernfalls, wenn T ein Aggregat-Typ ist, wird aggregierten Initialisierung durchgeführt .

  Original:

  Otherwise, if T is an aggregate type, aggregierten Initialisierung is performed.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Andernfalls, wenn T ist eine Spezialisierung der std::initializer_list eine neue std::initializer_list Objekt des gleichen Typs gebaut und eingesetzt zu lenken initialisieren oder kopieren initialisieren das Objekt vom Typ T, abhängig vom Kontext .

  Original:

  Otherwise, if T is a specialization of std::initializer_list, a new std::initializer_list object of the same type is constructed and used to direct-initialize or copy-initialize the object of type T, depending on context.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Andernfalls werden die constuctors der T betrachtet, in zwei Phasen:

  Original:

  Otherwise, the constuctors of T are considered, in two phases:

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Alle Konstruktoren, std::initializer_list nehmen als einziges Argument oder als erstes Argument, wenn die restlichen Argumente Standardwerte haben, werden geprüft und abgestimmt durch Überlastung Resolution gegen ein einzelnes Argument vom Typ std::initializer_list

  Original:

  All constructors that take std::initializer_list as the only argument, or as the first argument if the remaining arguments have default values, are examined, and matched by overload resolution against a single argument of type std::initializer_list

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Wenn der vorherigen Stufe nicht produziert ein Spiel, alle Konstruktoren T in Überlast Beschlussfassung teilnehmen gegen die Reihe von Argumenten, die aus den Elementen der braced-init-Liste besteht, mit der Einschränkung, dass nur einschränkende Konvertierungen erlaubt sind. Wenn dieses Stadium produziert einen expliziten Konstruktor als beste Übereinstimmung für eine Kopie-list-Initialisierung, Erstellung fehlschlägt (beachten Sie, in einfachen Copy-Initialisierung werden explizite Konstruktoren überhaupt nicht berücksichtigt)

  Original:

  If the previous stage does not produce a match, all constructors of T participate in overload resolution against the set of arguments that consists of the elements of the braced-init-list, with the restriction that only narrowing conversions are allowed. If this stage produces an explicit constructor as the best match for a copy-list-initialization, compilation fails (note, in simple copy-initialization, explicit constructors are not considered at all)

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Andernfalls, wenn T Referenz-Typ ist, ist ein prvalue vorübergehende des referenzierten Typs list-initialisiert, und der Verweis auf diese temporären gebunden .

  Original:

  Otherwise, if T is reference type, a prvalue temporary of the referenced type is list-initialized, and the reference is bound to that temporary.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Andernfalls, wenn die verspannt-init-Liste hat nur ein Element, T ist direkte initialisiert oder copy-initialisiert, abhängig vom Kontext, außer dass einschränkende Konvertierungen sind nicht erlaubt .

  Original:

  Otherwise, if the braced-init-list has only one element, T is direkte initialisiert or copy-initialisiert, depending on context, except that narrowing conversions are not allowed.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Andernfalls, wenn die verspannt-init-Liste keine Elemente, T ist Wert initialisiert .

  Original:

  Otherwise, if the braced-init-list has no elements, T is Wert initialisiert.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Einschränkende Konvertierungen

• Umwandlung von einer Floating-Point-Typ in einen Integer-Typ

  Original:

  conversion from a floating-point type to an integer type

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Umwandlung von einer long double um double oder float und Umwandlung von double um float, sofern nicht die Quelle ist ein konstanter Ausdruck dessen Wert genau in den Ziel-Typ gespeichert werden

  Original:

  conversion from a long double to double or to float and conversion from double to float, except where the source is a constant expression whose value can be stored exactly in the target type

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Umwandlung von ganzzahligen oder ohne Bereichseinschränkung Enumerationstyp um Ganzzahl, die sich nicht darstellen können alle Werte des ursprünglichen, sofern Quelle ist ein konstanter Ausdruck dessen Wert genau in den Ziel-Typ gespeichert werden

  Original:

  conversion from integer or unscoped enumeration type to integer type that cannot represent all values of the original, except where source is a constant expression whose value can be stored exactly in the target type

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Notes

[Bearbeiten] Beispiel

#include <iostream>
#include <vector>
#include <map>
#include <string>
 
struct Foo {
    std::vector<int> mem = {1,2,3}; // list-initialization of a non-static member
    std::vector<int> mem2;
    Foo() : mem2{-1, -2, -3} {} // list-initialization of a member in constructor
};
 
std::pair<std::string, std::string> f(std::pair<std::string, std::string> p)
{
    return {p.second, p.first}; // list-initialization in return statement
}
 
int main()
{
    int n0{};     // value-initialization (to zero)
    int n1{1};    // direct-list-initialization
    std::string s1{'a', 'b', 'c', 'd'}; // initializer-list constructor call
    std::string s2{s1, 2, 2};           // regular constructor call
    std::string s3{0x61, 'a'}; // initializer-list ctor is preferred to (int, char)
 
    int n2 = {1}; // copy-list-initialization
    double d = double{1.2}; // list-initialization of a temporary, then copy-init
 
    std::map<int, std::string> m = { // nested list-initialization
           {1, "a"},
           {2, {'a', 'b', 'c'} },
           {3, s1}
    };
 
    std::cout << f({"hello", "world"}).first // list-initialization in function call
              << '\n';
 
    const int (&ar)[2] = {1,2}; // binds a lvalue reference to a temporary array
    int&& r1 = {1}; // binds a rvalue reference to a temporary int
//  int& r2 = {2}; // error: cannot bind rvalue to a non-const lvalue ref
 
//  int bad{1.0}; // error: narrowing conversion
    unsigned char uc1{10}; // okay
//  unsigned char uc2{-1}; // error: narrowing conversion
 
    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 << ' ';
}

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

[Bearbeiten] Siehe auch

• Default-Initialisierung
• direkte Initialisierung
• aggregierten Initialisierung
• Kopieren Initialisierung