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 << "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()}; // return 문에서의 복사 목록 초기화
                                  // 이는 std::initializer_list의 사용이 아님
    }
};
template<typename T>
void templated_fn(T) {}
int main()
{
    S<int> s = {1, 2, 3, 4, 5}; // 복사 목록 초기화
    s.append({6, 7, 8});        // 함수 호출에서의 목록 초기화
    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}) // auto에 대한 규칙으로 이 범위 기반 for가 작동함
        std::cout << x << ' ';
    std::cout << '\n';
    auto al = {10, 11, 12}; // auto에 대한 특별 규칙
    std::cout << "The list bound to auto has size() = " << al.size() << '\n';
    auto la = al; // 최상위 프록시 객체의 얕은 복사
    assert(la.begin() == al.begin()); // 보장됨: 백업 배열이 동일함
    std::initializer_list<int> il{-3, -2, -1};
    assert(il.begin()[2] == -1); // 존재하지 않는 operator[]의 대체물 참고
    il = al; // 얕은 복사
    assert(il.begin() == al.begin()); // 보장됨
//  templated_fn({1, 2, 3}); // 컴파일러 오류! "{1, 2, 3}"은 표현식이 아니며,
                             // 타입이 없으므로 T를 추론할 수 없음
    templated_fn<std::initializer_list<int>>({1, 2, 3}); // OK
    templated_fn<std::vector<int>>({1, 2, 3});           // 또한 OK
}