vector<int> arr = { ,,,, };

或者

vector<int> arr{ ,,,, };

class foo {

public:

    std::vector<int> data;

    //构造函数里放上initialize_list

    foo() {}

    foo(std::initializer_list<int> list) :data(list) {}

    void print() {

        for (auto item : data) {

            std::cout << item;

        }

        std::cout << endl;

    }

};

int main() {

    foo test1{ ,,,, };

    foo test2 = { ,,,, };

    test1.print();

    test2.print();

    return ;

}

 #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 T*, std::size_t> c_arr() const {

         return{ &v[], v.size() };  // copy list-initialization in return statement

                                     // this is NOT a use of std::initializer_list

     }

 };

 template <typename T>

 void templated_fn(T) {}

 int main()

 {

     S<int> s = { , , , ,  }; // copy list-initialization

     s.append({ , ,  });      // 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 : {-, -, -}) // the rule for auto makes this ranged-for work

         std::cout << x << ' ';

     std::cout << '\n';

     auto al = { , ,  };   // 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>>({ , ,  }); // OK

     templated_fn<std::vector<int>>({ , ,  });           // also OK

 }