如果你的编译器支持c++ 11，你可以简单地这样做:

std::vector<int> v = {1, 2, 3, 4};

这在GCC 4.4版中可用。不幸的是，vc++ 2010在这方面似乎落后了。

或者是Boost。Assign库使用非宏魔术来允许以下:

#include <boost/assign/list_of.hpp>
...
std::vector<int> v = boost::assign::list_of(1)(2)(3)(4);

Or:

#include <boost/assign/std/vector.hpp>
using namespace boost::assign;
...
std::vector<int> v;
v += 1, 2, 3, 4;

但请记住，这有一些开销(基本上，list_of在底层构造了一个std::deque)，因此对于性能关键的代码，您最好按照Yacoby所说的那样做。

你可以使用boost::assign:

vector<int> values;
values += 1,2,3,4,5,6,7,8,9;

详情在这里。

开始:

int a[] = {10, 20, 30}; //I'm assuming 'a' is just a placeholder

如果你没有c++ 11编译器，也不想使用Boost:

const int a[] = {10, 20, 30};
const std::vector<int> ints(a, a+sizeof(a)/sizeof(int)); //Make it const if you can

如果你没有c++ 11编译器，可以使用Boost:

#include <boost/assign.hpp>
const std::vector<int> ints = boost::assign::list_of(10)(20)(30);

如果你有c++ 11编译器:

const std::vector<int> ints = {10,20,30};

对于向量初始化-

vector<int> v = {10, 20, 30}

如果你有c++ 11编译器就可以做到。

否则，你可以有一个数据数组，然后使用for循环。

int array[] = {10,20,30}
for(unsigned int i=0; i<sizeof(array)/sizeof(array[0]); i++)
{
     v.push_back(array[i]);
}

除此之外，在前面的回答中还描述了使用一些代码的各种其他方法。在我看来，这些方法容易记忆和快速书写。

如果你想把它放在你自己的课上:

#include <initializer_list>
Vector<Type>::Vector(std::initializer_list<Type> init_list) : _size(init_list.size()),
_capacity(_size),
_data(new Type[_size])
{
    int idx = 0;
    for (auto it = init_list.begin(); it != init_list.end(); ++it)
        _data[idx++] = *it;
}

// Before C++11
// I used following methods:

// 1.
int A[] = {10, 20, 30};                              // original array A

unsigned sizeOfA = sizeof(A)/sizeof(A[0]);           // calculate the number of elements

                                                     // declare vector vArrayA,
std::vector<int> vArrayA(sizeOfA);                   // make room for all
                                                     // array A integers
                                                     // and initialize them to 0 

for(unsigned i=0; i<sizeOfA; i++)
    vArrayA[i] = A[i];                               // initialize vector vArrayA


//2.
int B[] = {40, 50, 60, 70};                          // original array B

std::vector<int> vArrayB;                            // declare vector vArrayB
for (unsigned i=0; i<sizeof(B)/sizeof(B[0]); i++)
    vArrayB.push_back(B[i]);                         // initialize vArrayB

//3.
int C[] = {1, 2, 3, 4};                              // original array C

std::vector<int> vArrayC;                            // create an empty vector vArrayC
vArrayC.resize(sizeof(C)/sizeof(C[0]));              // enlarging the number of 
                                                     // contained elements
for (unsigned i=0; i<sizeof(C)/sizeof(C[0]); i++)
     vArrayC.at(i) = C[i];                           // initialize vArrayC


// A Note:
// Above methods will work well for complex arrays
// with structures as its elements.