std:: initializer_list

(à ne pas confondre avec member initializer list )

Un objet de type std::initializer_list<T> est un objet proxy léger qui fournit un accès à un tableau d'objets de type const T (qui peut être alloué en mémoire morte).

Un objet std::initializer_list est automatiquement construit lorsque :

• une liste d'initialisation entre accolades est utilisée pour initialiser par liste un objet, lorsque le constructeur correspondant accepte un paramètre de type std::initializer_list ,
• une liste d'initialisation entre accolades est utilisée comme opérande droit d'une assignation ou comme argument d'appel de fonction , et l'opérateur/fonction d'assignation correspondant accepte un paramètre de type std::initializer_list ,
• une liste d'initialisation entre accolades est liée à auto , y compris dans une boucle for à portée .

std::initializer_list peut être implémenté comme une paire de pointeurs ou un pointeur et une longueur. Copier un std::initializer_list ne copie pas le tableau sous-jacent de la liste d'initialisation correspondante.

Le programme est mal formé si une spécialisation explicite ou partielle de std::initializer_list est déclarée.

Types membres

Fonctions membres

Fonctions non membres

Notes

Exemple

#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 << "construit avec une liste de " << l.size() << " éléments\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()}; // initialisation par liste en copie dans l'instruction return
                                  // ceci n'est PAS une utilisation de std::initializer_list
    }
};
template<typename T>
void templated_fn(T) {}
int main()
{
    S<int> s = {1, 2, 3, 4, 5}; // initialisation par liste en copie
    s.append({6, 7, 8});        // initialisation par liste dans l'appel de fonction
    std::cout << "Le vecteur contient maintenant " << s.c_arr().second << " entiers:\n";    
    for (auto n : s.v)
        std::cout << n << ' ';
    std::cout << '\n';
    std::cout << "Boucle for sur liste d'initialisation entre accolades: \n";
    for (int x : {-1, -2, -3}) // la règle pour auto permet à cette boucle for de fonctionner
        std::cout << x << ' ';
    std::cout << '\n';
    auto al = {10, 11, 12}; // règle spéciale pour auto
    std::cout << "La liste liée à auto a size() = " << al.size() << '\n';
    auto la = al; // copie superficielle de l'objet proxy de haut niveau
    assert(la.begin() == al.begin()); // garanti : le tableau sous-jacent est le même
    std::initializer_list<int> il{-3, -2, -1};
    assert(il.begin()[2] == -1); // notez le remplacement pour l'opérateur [] absent
    il = al; // copie superficielle
    assert(il.begin() == al.begin()); // garanti
//  templated_fn({1, 2, 3}); // erreur de compilation ! "{1, 2, 3}" n'est pas une expression,
                             // il n'a pas de type, donc T ne peut pas être déduit
    templated_fn<std::initializer_list<int>>({1, 2, 3}); // OK
    templated_fn<std::vector<int>>({1, 2, 3});           // également OK
}

construit avec une liste de 5 éléments
Le vecteur contient maintenant 8 entiers:
1 2 3 4 5 6 7 8
Boucle for sur liste d'initialisation entre accolades:
-1 -2 -3
La liste liée à auto a size() = 3

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi