std:: initializer_list

(nicht zu verwechseln mit member initializer list )

Ein Objekt vom Typ std::initializer_list<T> ist ein leichtgewichtiges Proxy-Objekt, das Zugriff auf ein Array von Objekten vom Typ const T bietet (die sich in einem schreibgeschützten Speicherbereich befinden können).

Ein std::initializer_list -Objekt wird automatisch konstruiert, wenn:

• eine geschweifte Klammer-Initialisierungsliste wird verwendet, um ein Objekt Listen-initialisierung durchzuführen, wobei der entsprechende Konstruktor einen std::initializer_list -Parameter akzeptiert,
• eine geschweifte Klammer-Initialisierungsliste wird als rechter Operand einer Zuweisung oder als Funktionsaufrufargument verwendet, und der entsprechende Zuweisungsoperator/die entsprechende Funktion akzeptiert einen std::initializer_list -Parameter,
• eine geschweifte Klammer-Initialisierungsliste an auto gebunden wird, einschließlich in einer Bereichs-for-Schleife .

std::initializer_list kann als ein Paar von Zeigern oder als Zeiger und Länge implementiert werden. Das Kopieren einer std::initializer_list kopiert nicht das zugrunde liegende Array der entsprechenden Initialisierungsliste.

Das Programm ist fehlerhaft, wenn eine explizite oder partielle Spezialisierung von std::initializer_list deklariert wird.

Mitgliedertypen

Memberfunktionen

Nicht-Member-Funktionen

Hinweise

Beispiel

#include <cassert>
#include <initializer_list>
#include <iostream>
#include <vector>
template<class T>
struct S
{
    std::vector<T> v;
    S(std::initializer_list<T> l) : v(l)
    {
         std::cout << "constructed with a " << l.size() << "-element list\n";
    }
    void append(std::initializer_list<T> l)
    {
        v.insert(v.end(), l.begin(), l.end());
    }
    std::pair<const T*, std::size_t> c_arr() const
    {
        return {&v[0], v.size()}; // copy list-initialization in return statement
                                  // this is NOT a use of std::initializer_list
    }
};
template<typename T>
void templated_fn(T) {}
int main()
{
    S<int> s = {1, 2, 3, 4, 5}; // copy list-initialization
    s.append({6, 7, 8});        // list-initialization in function call
    std::cout << "The vector now has " << s.c_arr().second << " ints:\n";    
    for (auto n : s.v)
        std::cout << n << ' ';
    std::cout << '\n';
    std::cout << "Range-for over brace-init-list: \n";
    for (int x : {-1, -2, -3}) // the rule for auto makes this ranged-for work
        std::cout << x << ' ';
    std::cout << '\n';
    auto al = {10, 11, 12}; // special rule for auto
    std::cout << "The list bound to auto has size() = " << al.size() << '\n';
    auto la = al; // a shallow-copy of top-level proxy object
    assert(la.begin() == al.begin()); // guaranteed: backing array is the same
    std::initializer_list<int> il{-3, -2, -1};
    assert(il.begin()[2] == -1); // note the replacement for absent operator[]
    il = al; // shallow-copy
    assert(il.begin() == al.begin()); // guaranteed
//  templated_fn({1, 2, 3}); // compiler error! "{1, 2, 3}" is not an expression,
                             // it has no type, and so T cannot be deduced
    templated_fn<std::initializer_list<int>>({1, 2, 3}); // OK
    templated_fn<std::vector<int>>({1, 2, 3});           // also OK
}

constructed with a 5-element list
The vector now has 8 ints:
1 2 3 4 5 6 7 8
Range-for over brace-init-list:
-1 -2 -3
The list bound to auto has size() = 3

Fehlerberichte

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

Siehe auch