Espaces de noms
Variantes
Affichages
Actions

std::initializer_list

De cppreference.com
< cpp‎ | utility


 
 
 
std::initializer_list
Les fonctions membres
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
Capacité
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
Les itérateurs
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
Tiers fonctions
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;
(depuis C++11)
Un objet de std::initializer_list<T> type est un objet proxy léger, ce qui permet d'accéder à un tableau d'objets de T type, affecté par la mise en œuvre dans le stockage non précisée (qui pourrait être automatique, temporaire ou statique en lecture seule mémoire, en fonction de la situation)
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.
Ce tableau est initialisé et un objet std::initializer_list est construit quand un contreventés-init-list est utilisé dans liste d'initialisation, y compris initialisation de la liste d'appel de fonction et expression d'affectation (à ne pas confondre avec liste d'initialisation du constructeur), ou lorsque contreventés- init-list est lié à auto, y compris dans une boucle for .. variait
Original:
This array is initialized and a std::initializer_list object is constructed when a braced-init-list is used in liste d'initialisation, including function-call list initialization and assignment expression (not to be confused with liste d'initialisation du constructeur), 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.
Liste d'initialisation peut être mis en œuvre comme une paire de pointeurs ou des pointeurs et de la longueur. Copie d'un std::initializer_list ne copie pas les objets sous-jacents. Le tableau sous-jacent n'est pas garanti d'exister après la durée de vie de l'objet liste d'initialisation d'origine est terminée .
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.

Sommaire

[modifier] Types de membres

Type du membre Définition
value_type T
reference const T&
const_reference const T&
size_type size_t
iterator const T*
const_iterator const T*

[modifier] Fonctions membres

crée une liste d'initialisation vide
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.

(fonction membre publique) [edit]
Capacité
Original:
Capacity
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
renvoie le nombre d'éléments dans la liste d'initialisation
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.

(fonction membre publique) [edit]
Les itérateurs
Original:
Iterators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
renvoie un pointeur du premier élément
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.

(fonction membre publique) [edit]
renvoie un pointeur sur une après le dernier élément
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.

(fonction membre publique) [edit]

[modifier] Fonctions annexes

std::begin spécialisée
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.

(fonction générique) [edit]
std::end spécialisée
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.

(fonction générique) [edit]

[modifier] Exemple

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

Résultat :

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