std::initializer_list

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