c++ - 如何一次将多个整数传递给一个向量？

Question

目前当我必须vector.push_back()多次使用时。

我目前使用的代码是

  std::vector<int> TestVector;
  TestVector.push_back(2);
  TestVector.push_back(5);
  TestVector.push_back(8);
  TestVector.push_back(11);
  TestVector.push_back(14);

有没有办法只使用vector.push_back()一次并将多个值传递给向量？

Answer 1

您可以使用初始化列表来做到这一点：

std::vector<unsigned int> array;

// First argument is an iterator to the element BEFORE which you will insert:
// In this case, you will insert before the end() iterator, which means appending value
// at the end of the vector.
array.insert(array.end(), { 1, 2, 3, 4, 5, 6 });

Answer 2

尝试将数组传递给向量：

int arr[] = {2,5,8,11,14};
std::vector<int> TestVector(arr, arr+5);

您总是可以调用std::vector::assign将数组分配给向量，调用 std::vector::insert 添加多个数组。

如果你使用 C++11，你可以尝试：

std::vector<int> v{2,5,8,11,14};

或者

 std::vector<int> v = {2,5,8,11,14};

Answer 3

您也可以使用vector::insert。

std::vector<int> v;
int a[5] = {2, 5, 8, 11, 14};

v.insert(v.end(), a, a+5);

编辑：

当然，在实际编程中，您应该使用：

v.insert(v.end(), a, a+(sizeof(a)/sizeof(a[0])));  // C++03
v.insert(v.end(), std::begin(a), std::end(a));     // C++11

Answer 4

使用vector::insert (const_iterator position, initializer_list il); http://www.cplusplus.com/reference/vector/vector/insert/

#include <iostream>
#include <vector>

int main() {
  std::vector<int> vec;
  vec.insert(vec.end(),{1,2,3,4});
  return 0;
}

Answer 5

您还可以使用Boost.Assignment：

const list<int> primes = list_of(2)(3)(5)(7)(11);

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

Answer 6

这是三种最直接的方法：

1) 从初始化列表初始化：

std::vector<int> TestVector = {2,5,8,11,14};

2）从初始化列表分配：

std::vector<int> TestVector;
TestVector.assign( {2,5,8,11,14} ); // overwrites TestVector

3) 在给定点插入一个初始化列表：

std::vector<int> TestVector;
...
TestVector.insert(end(TestVector), {2,5,8,11,14} ); // preserves previous elements

Answer 7

这些天（c++17）很容易：

auto const pusher([](auto& v) noexcept
  {
    return [&](auto&& ...e)
      {
        (
          (
            v.push_back(std::forward<decltype(e)>(e))
          ),
          ...
        );
      };
  }
);

pusher(TestVector)(2, 5, 8, 11, 14);

编辑：对于真正喜欢冒险的人（c++20）：

template <typename F, class Tuple>
constexpr void operator|(Tuple&& t, F f)
{
  [&]<auto ...I>(std::index_sequence<I...>) noexcept(noexcept((f(std::get<I>(t)), ...)))
  {
    (f(std::get<I>(t)), ...);
  }
  (std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>());
}

std::forward_as_tuple(2, 5, 8, 11, 14) | [&](auto&& e){ TestVector.push_back(std::forward<decltype(e)>(e)); }

Answer 8

由于c++17您可以使用以下方法：

#include <iostream>
#include <vector>

using namespace std;

vector<int> vec;
template<typename... T>
void vecPush(const T& ... x) {
    (vec.push_back(x), ...);
}

int main() {
    vecPush(4, 10, 4);
    for(const auto& a : vec)
        cout << a << " ";
    return 0;
}

Answer 9

是的，你可以，在你的情况下：

vector<int>TestVector;`
for(int i=0;i<5;i++)
{

    TestVector.push_back(2+3*i);
    
}