Question

我有一个2d数组，比如A[2][3]={{1,2,3},{4,5,6}};，我想将它推入2D矢量（矢量矢量）。我知道你可以使用两个for loops将元素一个接一个地推到第一个向量，然后将其推入另一个向量，这使得它成为2d向量但是我想知道C ++中是否有任何方法可以做到这一点在一个循环中。例如，我想做这样的事情：

myvector.pushback(A[1]+3); // where 3 is the size or number of columns in the array.

我知道这不是一个正确的代码，但我这只是为了理解目的。感谢

Answer 1

新的C ++ 0x标准定义initializer_lists，允许您：

vector<vector<int>> myvector = {{1,2,3},{4,5,6}};

gcc 4.3+和其他一些编译器支持部分C ++ 0x。对于gcc 4.3+，您可以通过添加标志-std=c++0x

来启用c ++ 0x支持

这不是将静态数据表示为最佳方式。但是，如果您的编译器供应商支持C ++ tr1，那么您可以这样做：

#include <tr1/array>  // or #include <array>
...

typedef vector<vector<int> > vector2d;
vector2d myvector;

// initialize the vectors
myvector.push_back(vector<int>());
myvector.push_back(vector<int>());

typedef std::array<std::array<int, 3>, 2> array2d;
array2d array = {{1,2,3},{4,5,6}};
array2d::const_iterator ai = array.begin(), ae = array.end();
for (vector2d::iterator i = myvector.begin(), e = myvector.end()
    ; i != e && ai != ae
    ; i++, a++)
{
    // reserve vector space
    i->reserve(array.size());

    // copy array content to vector
    std::copy(ai.begin(), ai->end(), i->begin());
}

Answer 2

您可以使用vector::assign（指向数组元素的指针是有效的迭代器）：

int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
std::vector<std::vector<int> > v(2);
for (size_t i = 0; i < 2; ++i)
   v[i].assign(a[i], a[i] + 3);

Answer 3

这有点棘手，但您可以使用模板递归来帮助您在编译时完成任务。我明白这并不是你想要的，但我认为这是值得的： - ）

以下是代码：

#include <vector>

using namespace std;

typedef vector<vector<int> > vector2d;

template<size_t K, size_t M, size_t N>
struct v_copy {
    static void copy(vector2d& v, int(&a)[M][N])
    {
        v[K - 1].assign(a[K - 1], a[K - 1] + N);
        v_copy<K - 1, M, N>::copy(v, a);
    }
};

template<size_t M, size_t N>
struct v_copy<1, M, N> {
    static void copy(vector2d& v, int(&a)[M][N])
    {
        v[0].assign(a[0], a[0] + N);
    }
};

template<size_t M, size_t N>
void copy_2d(vector2d& v, int(&a)[M][N])
{
    v_copy<M, M, N>::copy(v, a);
}

int main()
{
    int A[2][3] = {{0, 1, 2}, {10, 11, 12}};
    vector2d vector(2);

    copy_2d(vector, A);
}

它需要一个结构，因为在C ++中你不能对函数进行部分特化。顺便说一句，用gcc版本4.5.0编译它，这段代码生成与

相同的程序集

vector[1].assign(A[1], A[1] + 3);
vector[0].assign(A[0], A[0] + 3);

使用不同类型的2维数组进行编译应该不是很难。

Answer 4

如果要将数据推送到向量的向量中，则必须编写如下内容：

vector<int> inner;
vector< vector<int> >outer;

...
outer.pushback(inner);

我认为没有办法在一个循环中完成它。

如果你只想使用一个向量（就像你写的那样），那么你可以在一个循环中完成它：

int A[2][3]={{1,2,3},{4,5,6}};
int* p = A[0];
std::vector<int> inner;
std::vector< std::vector<int> >outer;

for(int i = 0; i < 6; ++i)
{
    inner.push_back(*p++);
}

Answer 5

这有点作弊，但你可以利用vector constructor为你做一个循环：

#include <vector>

int main() {
  const int XMAX = 2, YMAX = 3;
  int A[XMAX][YMAX] = {{1,2,3}, {4,5,6}};
  std::vector<std::vector<int> > v;

  for (size_t x = 0; x < XMAX; ++x) {
    v.push_back(std::vector<int>(&A[x][0], &A[x][YMAX]));
  }
}

Answer 6

您可以调整矢量大小，然后使用副本。

int A[2][3]={{1,2,3},{4,5,6}};
std::vector< std::vector<int> > vec;

vec.resize(2);
for (int i=0; i<2; i++)
{
    vec[i].resize(3);
    std::copy(A[i], A[i]+3, vec[i].begin());
}

实用吗？绝对不是。

Answer 7

嗯...我可以产生部分答案但不能完整答案。

int elementCount = 6; // I wonder if this can be done somehow with sizeof(A) * sizeof(A[0])
int* end = A + elementCount;
for(int* current = A; current < end; ++current) {
    myvector.pushback(*current);
}

Answer 8

没有。你唯一能做的就是利用现有的循环函数，这样你只需要写一个或零个循环。

将数组推入向量

8 个答案: