std::initializer_list

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::initializer_list

Memberfunktionen

initializer_list::initializer_list

Kapazität

initializer_list::size

Iteratoren

initializer_list::begin

initializer_list::end

Nicht-Member-Funktionen

begin(std::initializer_list)

end(std::initializer_list)

 

(nicht zu verwechseln mit Member-Initialisierungsliste)

Definiert in der Header-Datei <initializer_list>
template< class T > class initializer_list;		(seit C++11)

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 (das im schreibgeschützten Speicher allokiert sein kann).

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

• eine in geschweifte Klammern eingeschlossene Initialisierungsliste verwendet wird, um ein Objekt zu listeninitialisieren, wobei der entsprechende Konstruktor einen std::initializer_list-Parameter akzeptiert,
• eine in geschweifte Klammern eingeschlossene Initialisierungsliste als rechtes Operand für eine Zuweisung oder als Argument für einen Funktionsaufruf verwendet wird und der entsprechende Zuweisungsoperator/die entsprechende Funktion einen std::initializer_list-Parameter akzeptiert,
• eine in geschweifte Klammern eingeschlossene Initialisierungsliste an auto gebunden wird, auch in einer Bereichs-for-Schleife.

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

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

Member-Typen

Name	Definition
value_type	T
Referenz	const T&
const_reference	const T&
size_type	std::size_t
iterator	const T*
const_iterator	const T*

Member-Funktionen

(Konstruktor)	erstellt eine leere Initialisierungsliste (public member function)
Kapazität
size	gibt die Anzahl der Elemente in der Initialisierungsliste zurück (public member function)
Iteratoren
begin	gibt einen Zeiger auf das erste Element zurück (public member function)
end	gibt einen Zeiger auf ein Element nach dem letzten Element zurück (public member function)

Nicht-Member-Funktionen

std::begin(std::initializer_list) (C++11)	überlädt std::begin (function template)
std::end(std::initializer_list) (C++11)	spezialisiert std::end (function template)
Freie Funktions-Templates, die für std::initializer_list überladen sind
rbegincrbegin (C++14)	gibt einen Reverse-Iterator zum Anfang eines Containers oder Arrays zurück (function template)
rendcrend (C++14)	gibt einen Reverse-End-Iterator für einen Container oder ein Array zurück (function template)
empty (C++17)	prüft, ob der Container leer ist (function template)
data (C++17)	erhält den Zeiger auf das zugrundeliegende Array (function template)

Anmerkungen

Feature-Testmakro	Wert	Std	Feature
__cpp_initializer_lists	200806L	(C++11)	Listeninitialisierung und std::initializer_list

Beispiel

Führen Sie diesen Code aus

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

Ausgabe

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.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2129	C++11	std::initializer_list könnte explizit sein Spezialisierungen oder partielle Spezialisierungen	das Programm ist ill-formed in diesem Fall

Siehe auch

span (C++20)	eine nicht besitzende Ansicht über eine zusammenhängende Sequenz von Objekten (class template)
basic_string_view (C++17)	schreibgeschützte String-Ansicht (class template)