Namensräume
Varianten
Aktionen

std::initializer_list

Aus cppreference.com
< cpp‎ | utility


 
 
 
std::initializer_list
Member-Funktionen
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
initializer_list::initializer_list
Kapazität
Original:
Capacity
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
initializer_list::size
Iteratoren
Original:
Iterators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
initializer_list::begin
initializer_list::end
Non-Member-Funktionen
Original:
Non-member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
std::begin
std::end
 
Defined in header <initializer_list>
template< class T >
class initializer_list;
(seit C++11)
Ein Objekt vom Typ std::initializer_list<T> ist ein leichtes Proxy-Objekt, das den Zugriff auf ein Array von Objekten vom Typ T, durch die Implementierung in unspezifizierter Speicher (was könnte automatisch, temporäre oder statische Festwertspeicher, abhängig von der Situation zugeordneten )
Original:
An object of type std::initializer_list<T> is a lightweight proxy object, which provides access to an array of objects of type T, allocated by the implementation in unspecified storage (which could be automatic, temporary, or static read-only memory, depending on the situation)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Dieses Array wird initialisiert und ein std::initializer_list Objekt konstruiert, wenn ein verspannt-init-list in list-Initialisierung verwendet wird, einschließlich Funktion-Call-Liste Initialisierung und Zuweisung Ausdruck (nicht mit Konstruktor Initialisierungsliste verwechselt werden), oder wenn verspannt-init-list wird auto gebunden, einschließlich in einer reichten for-Schleife .
Original:
This array is initialized and a std::initializer_list object is constructed when a braced-init-list is used in list-Initialisierung, including function-call list initialization and assignment expression (not to be confused with Konstruktor Initialisierungsliste), or when braced-init-list is bound to auto, including in a ranged for loop.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Initializer Liste kann als ein Paar von Zeigern oder Zeiger und Länge realisiert werden. Kopieren eines std::initializer_list kopiert nicht die zugrunde liegenden Objekte. The zugrunde liegende Array ist nicht garantiert, nach der Lebensdauer des ursprünglichen Initialisierungsliste Objekt vorhanden ist beendet .
Original:
Initializer list may be implemented as a pair of pointers or pointer and length. Copying a std::initializer_list does not copy the underlying objects. The underlying array is not guaranteed to exist after the lifetime of the original initializer list object has ended.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Inhaltsverzeichnis

[Bearbeiten] Mitglied Typen

Mitglied Typ
Original:
Member type
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Definition
value_type T
reference const T&
const_reference const T&
size_type size_t
iterator const T*
const_iterator const T*

[Bearbeiten] Member-Funktionen

erzeugt ein leeres Initialisierungsliste
Original:
creates an empty initializer list
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(öffentliche Elementfunktion) [edit]
Kapazität
Original:
Capacity
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
liefert die Anzahl der Elemente in der Initialisierungsliste
Original:
returns the number of elements in the initializer list
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(öffentliche Elementfunktion) [edit]
Iteratoren
Original:
Iterators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
liefert einen Zeiger das erste Element
Original:
returns a pointer the first element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(öffentliche Elementfunktion) [edit]
einen Zeiger auf ein nach dem letzten Element
Original:
returns a pointer to one past the last element
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(öffentliche Elementfunktion) [edit]

[Bearbeiten] Non-Member-Funktionen

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

(Funktions-Template) [edit]
spezialisiert std::end
Original:
specializes std::end
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(Funktions-Template) [edit]

[Bearbeiten] Beispiel

#include <iostream>
#include <vector>
#include <initializer_list>
 
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 int*, size_t> c_arr() const {
        return {&v[0], v.size()};  // list-initialization in return statement
    }
};
 
template<typename T>
void templated_fn(T) { }
 
int main()
{
    S<int> s = {1,2,3,4,5}; // direct list-initialization
    s.append({6,7,8});      // list-initialization in function call
    std::cout << "The vector size is now " << 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';
 
//    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
}

Output:

The vector size is now 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