如果可以，使用现代c++[11,14,17,20，…]):

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

在变长数组上循环或使用sizeof()的旧方法真的很糟糕，而且在精神开销方面完全没有必要。讨厌的东西。

在c++ 0x中，你可以用与数组相同的方式来做这件事，但不是在当前的标准中。

只有语言支持，您可以使用:

int tmp[] = { 10, 20, 30 };
std::vector<int> v( tmp, tmp+3 ); // use some utility to avoid hardcoding the size here

如果你可以添加其他库，你可以尝试boost::assignment:

vector<int> v = list_of(10)(20)(30);

要避免硬编码数组的大小:

// option 1, typesafe, not a compile time constant
template <typename T, std::size_t N>
inline std::size_t size_of_array( T (&)[N] ) {
   return N;
}
// option 2, not typesafe, compile time constant
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

// option 3, typesafe, compile time constant
template <typename T, std::size_t N>
char (&sizeof_array( T(&)[N] ))[N];    // declared, undefined
#define ARRAY_SIZE(x) sizeof(sizeof_array(x))

对于向量初始化-

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]);
}

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

// 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.

有各种方法来硬编码一个向量。我将分享一些方法:

通过逐个推入值来初始化 //创建一个空向量 向量< int > vect; vect.push_back (10); vect.push_back (20); vect.push_back (30); 初始化类似数组 Vector <int> Vector {10,20,30}; 从数组初始化 Int arr[] = {10,20,30}; Int n = sizeof(arr) / sizeof(arr[0]); Vector <int> Vector (arr, arr + n); 从另一个向量初始化 Vector <int> vect1{10,20,30}; Vector <int> Vector (Vector 1.begin()， Vector 1.end()));

这里有很多很好的答案，但由于我在阅读这篇文章之前独立地得到了我自己的答案，我想无论如何我都要在这里抛出我的答案……

下面是我使用的一个方法，它将在编译器和平台上普遍工作:

创建一个结构体或类作为对象集合的容器。为<<定义运算符重载函数。

class MyObject;

struct MyObjectList
{
    std::list<MyObject> objects;
    MyObjectList& operator<<( const MyObject o )
    { 
        objects.push_back( o );
        return *this; 
    }
};

你可以创建以你的结构体作为参数的函数，例如:

someFunc( MyObjectList &objects );

然后，你可以调用这个函数，像这样:

someFunc( MyObjectList() << MyObject(1) <<  MyObject(2) <<  MyObject(3) );

这样，您就可以在一行代码中构建并将动态大小的对象集合传递给函数!