用硬编码元素初始化 std::vector 的最简单方法是什么？答案

【问题标题】：What is the easiest way to initialize a std::vector with hardcoded elements?用硬编码元素初始化 std::vector 的最简单方法是什么？
【发布时间】：2011-01-15 05:23:33
【问题描述】：

我可以创建一个数组并像这样初始化它：

int a[] = {10, 20, 30};

如何创建std::vector 并以同样优雅的方式初始化它？

我知道的最好方法是：

std::vector<int> ints;

ints.push_back(10);
ints.push_back(20);
ints.push_back(30);

有没有更好的办法？

【问题讨论】：

如果初始化后不打算改变int的大小，可以考虑使用tr1数组。
@zr，你让我很好奇......如果我需要固定大小，我不能自己使用普通的旧数组吗？现在正在查看 tr1 数组...
tr1::array 很有用，因为普通数组不提供 STL 容器的接口
更改了标题，使其明确成为 C++03 问题。这似乎比通过新标准 C++ 解决所有问题更容易。
这叫list initialization。

标签： c++ vector stl initialization

【解决方案1】：

如果可以，请使用现代 C++[11,14,17,20,...] 方式：

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

循环可变长度数组或使用sizeof() 的旧方法在视觉上确实很糟糕，并且在精神开销方面完全没有必要。呸。

【讨论】：

公平地说，这原本是一个 C++03 问题，但我希望人们/公司采用新标准。 C++ 仍然需要标准库中的可变长度数组 (VLA) 实现，类似于 Eigen 和 Boost 中可用的。
不幸的是，这种方法在某些情况下是有问题的，例如open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1467。糟糕。
如果“从相同类型的对象中对聚合进行列表初始化”是您的事情，那么您的代码库中可能存在更大的问题......我想不出任何应用程序可以证明它是合理的调试问题。
2018 年的答案，仍然使用 ={}?
还是不需要=

【解决方案2】：

如果数组是：

int arr[] = {1, 2, 3};
int len = (sizeof(arr)/sizeof(arr[0])); // finding length of array
vector < int > v;
v.assign(arr, arr+len); // assigning elements from array to vector

【讨论】：

这段代码能编译吗？最后一行看起来像是一个语法错误，因为它会被解析为(std::v).assign(arr, arr + len);，而namespace std 中没有v。还是你的意思是std::vector<int> v; v.assign(...);？

【解决方案3】：

您可以使用 boost::assign:

做到这一点

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

Details are here.

【讨论】：

我已经很久没有见过更糟糕的运营商重载滥用的案例了。 += 是否将 1,2,3,4.. 附加到值的末尾，还是 add 1 到第一个元素，2 到第二个元素，3 到第三个元素（像这样的语法应该在类 MATLAB 语言中）

【解决方案4】：

我倾向于声明

template< typename T, size_t N >
std::vector<T> makeVector( const T (&data)[N] )
{
    return std::vector<T>(data, data+N);
}

在某处的实用程序标题中，然后所需的只是：

const double values[] = { 2.0, 1.0, 42.0, -7 };
std::vector<double> array = makeVector(values);

【讨论】：

此技术还可用于重载函数以接受具有类型大小的数组。
您能解释一下const T (&data)[N] 部分吗？在您的电话makeVector(values) 中如何推断出数组的大小？

【解决方案5】：

如果你不想使用 Boost，但想享受类似的语法

std::vector<int> v;
v+=1,2,3,4,5;

只需包含这段代码

template <class T> class vector_inserter{
public:
    std::vector<T>& v;
    vector_inserter(std::vector<T>& v):v(v){}
    vector_inserter& operator,(const T& val){v.push_back(val);return *this;}
};
template <class T> vector_inserter<T> operator+=(std::vector<T>& v,const T& x){
    return vector_inserter<T>(v),x;
}

【讨论】：

我还没弄清楚如何使用这段代码，但看起来很有趣。
就像上面的评论之一。只是重载 += 和逗号运算符。为清楚起见，加上括号：((((v+=1),2),3),4),5) 这是它的工作原理：首先，vector<T> += T 返回一个vector_inserter，我们称之为vi，它封装了原始向量，然后vi,T 将T 添加到vi 封装并返回的原始向量自我，这样我们就可以再次vi,T。
此代码在 gcc 4.2.1 上无法正常工作，我认为是因为在 += 运算符中返回了对局部变量的引用，但想法非常好。我编辑了代码，又出现了一个复制构造函数。流程现在是 -> += -> ctor -> comma -> copy -> dtor -> comma ...... -> comma -> dtor。
我可能会重载

【解决方案6】：

在 C++11 中：

#include <vector>
using std::vector;
...
vector<int> vec1 { 10, 20, 30 };
// or
vector<int> vec2 = { 10, 20, 30 };

使用升压list_of：

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

使用 Boost 赋值：

#include <vector>
#include <boost/assign/std/vector.hpp>
using std::vector;
...
vector<int> vec;
vec += 10, 20, 30;

传统 STL：

#include <vector>
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

带有通用宏的传统 STL：

#include <vector>
#define ARRAY_SIZE(ar) (sizeof(ar) / sizeof(ar[0])
#define ARRAY_END(ar) (ar + ARRAY_SIZE(ar))
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec (arr, ARRAY_END(arr));

带有向量初始化器宏的传统 STL：

#include <vector>
#define INIT_FROM_ARRAY(ar) (ar, ar + sizeof(ar) / sizeof(ar[0])
using std::vector;
...
static const int arr[] = {10,20,30};
vector<int> vec INIT_FROM_ARRAY(arr);

【讨论】：

C++11 还支持std::begin 和std::end 用于数组，所以向量也可以像static const int arr[] = {10,20,30}; vector<int> vec(begin(arr), end(arr)); 一样初始化。

【解决方案7】：

开始于：

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

【讨论】：

【解决方案8】：

最近的重复问题有this answer 和Viktor Sehr。对我来说，它结构紧凑、视觉上吸引人（看起来你正在“推入”值），不需要C++11 或第三方模块，并且避免使用额外的（书面）变量。以下是我如何使用它并进行一些更改。将来我可能会改用扩展vector和/或va_arg的功能。

// Based on answer by "Viktor Sehr" on Stack Overflow
// https://stackoverflow.com/a/8907356
//
template <typename T>
class mkvec {
    public:
        typedef mkvec<T> my_type;
        my_type& operator<< (const T& val) {
            data_.push_back(val);
            return *this;
        }
        my_type& operator<< (const std::vector<T>& inVector) {
            this->data_.reserve(this->data_.size() + inVector.size());
            this->data_.insert(this->data_.end(), inVector.begin(), inVector.end());
            return *this;
        }
        operator std::vector<T>() const {
            return data_;
        }
    private:
        std::vector<T> data_;
};

std::vector<int32_t> vec1;
std::vector<int32_t> vec2;

vec1 = mkvec<int32_t>() << 5 << 8 << 19 << 79;
// vec1 = (5, 8, 19, 79)
vec2 = mkvec<int32_t>() << 1 << 2 << 3 << vec1 << 10 << 11 << 12;
// vec2 = (1, 2, 3, 5, 8, 19, 79, 10, 11, 12)

【讨论】：

【解决方案9】：

以下方法可用于在 C++ 中初始化向量。

int arr[] = {1, 3, 5, 6}; vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));
vector<int>v; v.push_back(1); v.push_back(2); v.push_back(3);等等
vector<int>v = {1, 3, 5, 7};

第三个只允许在C++11以后。

【讨论】：

【解决方案10】：

C++ 11 之前：

方法一

vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));
vector<int>v;

方法2

 v.push_back(SomeValue);

C++ 11 以下也可以

vector<int>v = {1, 3, 5, 7};

我们也可以这样做

vector<int>v {1, 3, 5, 7}; // Notice .. no "=" sign

对于 C++ 17 以后我们可以省略类型

vector v = {1, 3, 5, 7};

【讨论】：

不适用于具有单个元素的向量。

【解决方案11】：

用于向量初始化 -

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

除此之外，之前的答案中还使用一些代码描述了各种其他方式。在我看来，这些方式很容易记住，写起来也很快。

【讨论】：

【解决方案12】：

有多种方法可以对向量进行硬编码。我将分享几种方法：

通过一个一个推送值来初始化

// Create an empty vector
vector<int> vect;

vect.push_back(10);
vect.push_back(20);
vect.push_back(30);

初始化类似数组
```
vector<int> vect{ 10, 20, 30 };
```

从数组初始化

int arr[] = { 10, 20, 30 };
int n = sizeof(arr) / sizeof(arr[0]);

vector<int> vect(arr, arr + n);

从另一个向量初始化

vector<int> vect1{ 10, 20, 30 };

vector<int> vect2(vect1.begin(), vect1.end());

【讨论】：

最后一个可以简化为auto vect2 = vect1;或vector<int> vect2 = vect1，对吧？

【解决方案13】：

最简单、符合人体工程学的方式（使用 C++ 11 或更高版本）：

auto my_ints = {1,2,3};

【讨论】：

这不会将my_ints 推断为std::initializer_list<int> 而不是std::vector<int>？

【解决方案14】：

“我如何创建一个 STL 向量并像上面那样初始化它？以最少的输入工作量最好的方法是什么？”

在初始化内置数组时初始化向量的最简单方法是使用初始化列表在 C++11 中引入。

// Initializing a vector that holds 2 elements of type int.
Initializing:
std::vector<int> ivec = {10, 20};


// The push_back function is more of a form of assignment with the exception of course
//that it doesn't obliterate the value of the object it's being called on.
Assigning
ivec.push_back(30);

ivec在Assigning（带标签的语句）执行后的大小是3个元素。

【讨论】：

在类似的行中，我正在尝试初始化地图 std::map catinfo = { {1, false} };但随后得到这个错误错误：在 C++98 中，'catinfo' 必须由构造函数初始化，而不是由 '{...}'

【解决方案15】：

这里有很多很好的答案，但由于我在阅读本文之前独立得出了自己的答案，所以我想我还是把我的扔在这里......

这是我正在使用的一种方法，它将在编译器和平台上通用：

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

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

这样，您可以在一条干净的行中构建动态大小的对象集合并将其传递给函数！

【讨论】：

【解决方案16】：

如果您想在自己的班级中使用它：

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

【讨论】：

【解决方案17】：

在写测试的时候不用定义变量就可以直接创建vector inline，例如：

assert(MyFunction() == std::vector<int>{1, 3, 4}); // <- this.

【讨论】：

【解决方案18】：

我使用va_arg 构建自己的解决方案。此解决方案符合 C++98。

#include <cstdarg>
#include <iostream>
#include <vector>

template <typename T>
std::vector<T> initVector (int len, ...)
{
  std::vector<T> v;
  va_list vl;
  va_start(vl, len);
  for (int i = 0; i < len; ++i)
    v.push_back(va_arg(vl, T));
  va_end(vl);
  return v;
}

int main ()
{
  std::vector<int> v = initVector<int> (7,702,422,631,834,892,104,772);
  for (std::vector<int>::const_iterator it = v.begin() ; it != v.end(); ++it)
    std::cout << *it << std::endl;
  return 0;
}

Demo

【讨论】：

【解决方案19】：

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

【讨论】：

【解决方案20】：

B. Stroustrup 在 Prog 的 C++11 版本的第 464 页的 16.2.10 Selfreference 中描述了一种链接操作的好方法。朗。其中一个函数返回一个引用，这里修改为一个向量。通过这种方式，您可以像 v.pb(1).pb(2).pb(3); 一样链接，但对于这么小的收益来说可能工作量太大。

#include <iostream>
#include <vector>

template<typename T>
class chain
{
private:
    std::vector<T> _v;
public:
    chain& pb(T a) {
        _v.push_back(a);
        return *this;
    };
    std::vector<T> get() { return _v; };
};

using namespace std;

int main(int argc, char const *argv[])
{
    chain<int> v{};

    v.pb(1).pb(2).pb(3);

    for (auto& i : v.get()) {
        cout << i << endl;
    }

    return 0;
}

1
2
3

【讨论】：

犰狳库为矩阵初始化执行此操作，但使用 arma.sourceforge.net/docs.html#element_initialisation

【解决方案21】：

在 C++11 中：

static const int a[] = {10, 20, 30};
vector<int> vec (begin(a), end(a));

【讨论】：

如果您已经在使用 C++11，您不妨直接使用 - vector<int> arr = {10, 20, 30};。
实际上我有一个传入的 int[]（一些 C 库）并想推入一个向量（C++ 库）。这个答案有帮助，其余的没有;-)

【解决方案22】：

typedef std::vector<int> arr;

arr a {10, 20, 30};       // This would be how you initialize while defining

编译使用：

clang++ -std=c++11 -stdlib=libc++  <filename.cpp>

【讨论】：

问题状态 C++ 03（不是 11）
我认为当我回答这个问题时它没有指定 03。不过记得不是很全。但是，对于寻求快速解决方案的人来说，这仍然是一个有用的答案。

【解决方案23】：

如果你的编译器支持 C++11，你可以这样做：

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

这在 GCC as of version 4.4 中可用。不幸的是，VC++ 2010 在这方面似乎落后了。

或者，Boost.Assign 库使用非宏魔法来允许以下操作：

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

或者：

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

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

【讨论】：

由于向量是自定大小的，是否也可以将其初始化为空？就像在构造函数中一样：this->vect = {};?
@Azurespot 你可以初始化它，它会是空的：std::vector<T> vector;
以防万一有人对std::vector<int> v = {1, 2, 3, 4};感兴趣，vector的initializer list constructor会被调用来进行这种初始化，它的文档可以在C++ 11 section找到。

【解决方案24】：

在 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))

【讨论】：

当然我没有投反对票，但我还是有一个问题：数组的大小何时不是编译时间常数？即，在哪种情况下，您会在第二个 sn-p 中使用第一个解决方案而不是第三个解决方案？
@Manuel，数组的大小是类型的一部分，因此它是编译时间常数。现在，选项 1 使用该编译时间常数“N”作为函数的返回值。函数的返回不是编译时间，而是运行时值，即使它可能会在调用位置内联为常量值。不同的是你不能做：int another[size_of_array(array)]，而你可以做int another[ARRAY_SIZE(array)]。
在选项 3 中：我真的不明白您所说的“已声明，未定义”是什么意思？那么变量不会占用额外的内存？
@To1ne 实际上是一个函数声明，而不是一个变量。使用或定义它的原因是，除了不需要定义的sizeof 表达式之外，我们实际上并不希望该函数用于其他任何东西。虽然您实际上可以提供定义，但要正确执行，需要静态分配数组并返回对它的引用，下一个问题是数组的值是什么？（另请注意，这意味着函数实例的每个类型/大小组合都有一个数组！）由于它没有合理的用途，我宁愿避免它。
@mhd：您不能在该语言中构造一个空数组。 'int arr[0] = {};'不是有效的 C++ 代码。但是你是对的，如果你想初始化一个空向量和一个非空向量，你将不得不使用不同的构造。由于 C++11 这不是问题，因为您可以使用初始化列表构造函数

【解决方案25】：

相关，如果你想在一个快速语句中完全准备好一个向量（例如立即传递给另一个函数），你可以使用以下内容：

#define VECTOR(first,...) \
   ([](){ \
   static const decltype(first) arr[] = { first,__VA_ARGS__ }; \
   std::vector<decltype(first)> ret(arr, arr + sizeof(arr) / sizeof(*arr)); \
   return ret;})()

示例函数

template<typename T>
void test(std::vector<T>& values)
{
    for(T value : values)
        std::cout<<value<<std::endl;
}

示例使用

test(VECTOR(1.2f,2,3,4,5,6));

虽然要注意 decltype，但请确保第一个值明确是您想要的。

【讨论】：

【解决方案26】：

最简单的方法是：

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

【讨论】：

哪个编译器？你在这里使用 C++11 吗？
g++ 4.6.3 with -std=c++0x.

【解决方案27】：

如果您的编译器支持Variadic macros（对于大多数现代编译器都是如此），那么您可以使用以下宏将向量初始化转换为单行：

#define INIT_VECTOR(type, name, ...) \
static const type name##_a[] = __VA_ARGS__; \
vector<type> name(name##_a, name##_a + sizeof(name##_a) / sizeof(*name##_a))

使用此宏，您可以使用如下代码定义一个已初始化的向量：

INIT_VECTOR(int, my_vector, {1, 2, 3, 4});

这将创建一个名为 my_vector 的新整数向量，其中包含元素 1、2、3、4。

【讨论】：

【解决方案28】：

如果您想要与 Boost::assign 具有相同一般顺序的东西而不创建对 Boost 的依赖，则以下内容至少大致相似：

template<class T>
class make_vector {
    std::vector<T> data;
public:
    make_vector(T const &val) { 
        data.push_back(val);
    }

    make_vector<T> &operator,(T const &t) {
        data.push_back(t);
        return *this;
    }

    operator std::vector<T>() { return data; }
};

template<class T> 
make_vector<T> makeVect(T const &t) { 
    return make_vector<T>(t);
}

虽然我希望使用它的语法更简洁，但它仍然不是特别糟糕：

std::vector<int> x = (makeVect(1), 2, 3, 4);

【讨论】：

【解决方案29】：

一种方法是使用数组来初始化向量

static const int arr[] = {16,2,77,29};
vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) );

【讨论】：

@Agnel 没有static 或const 也可以正常工作，但是它们都更明确地说明了应该如何使用它并允许编译器进行额外的优化。
我没有对此表示反对，但我很受诱惑。主要是因为这几乎不会为您节省任何费用，而不仅仅是首先使用初始化的数组。然而，这真的是 C++ 的错，不是你的。
你能解释一下为什么在定义 vec 向量时使用这些参数吗？
sizeof(array) 是允许获取数组元素的总大小而不是 arr 指针维度的少数例外之一。所以基本上他使用的是vector（pointer_to_first_element，pointer_to_first_element + size_in_bytes_of_the_whole_array / size_of_one_element），即：vector（pointer_to_first_element，pointer_after_final_element）。已经给出了类型，所以向量知道一个元素有多少。请记住，迭代器可以被视为指针，因此您基本上使用的是 vector(iterator begin, iterator end) 构造函数
@T.E.D：有时您需要修改结果向量。例如，您可能需要始终拥有一些默认参数，有时还需要为它们添加一些自定义参数。