将多维数组复制到向量，反之亦然

Copy multidimensional array to vector and vice versa

本文关键字：向量 反之亦然 复制 数组      更新时间：2023-10-16
int dArray[1600][32];
vector < vector <int> > dVector;
n= 1600; k = 32
dVector.resize(n);
for(int i = 0 ; i < n ; ++i){
dVector[i].resize(k);
}
std::copy ( dArray, dArray + tmp_c, std::back_inserter (dVector));

如何使用std::copy(或任何其他函数)将多维数组复制到向量，反之亦然?

您不能直接这样做，而是通过中间步骤。根据您的需求，像这样的vector_wrapper可能适合您

#include <vector>
template<typename T, int N> struct vector_wrapper {
    vector_wrapper(T (&a)[N]) {
        std::copy(a, a + N, std::back_inserter(v));
    }
    std::vector<T> v;
};
int dArray[1600][32];
std::vector<vector_wrapper<int, 32> > dVector;
int main(int argc, char **argv)
{
    std::copy(dArray, dArray + 1600, std::back_inserter(dVector));
    return 0;
}

您基本上需要编写自己的output iterator类型。它有点难看，但是像这样的代码应该可以达到目的:

#include <vector>
#include <algorithm>
#include <iostream>
#include <iterator>
template <typename ContainerOfContainer, typename Container, std::size_t n>
struct nested_back_inserter : public std::iterator<std::output_iterator_tag, void, 
                                                   void, void, void>
{
   std::size_t k;
   std::size_t current_;
   ContainerOfContainer* container_;
   explicit nested_back_inserter(ContainerOfContainer& cont)
     : k(0), current_(0), container_(&cont)
   { }
   nested_back_inserter& operator=(typename Container::value_type value)
   {
       if(k == n) {
           ++current_;
           k = 0;
       }
       (*container_)[current_].push_back(value);
       ++k;
       return *this;
   }
   nested_back_inserter& operator*()
   {
       return *this;
   } 
   nested_back_inserter& operator++()
   {
       return *this;
   }
   nested_back_inserter& operator++(int)
   {
       return *this;
   }
};
int main()
{
    int arr[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}};
    std::vector<std::vector<int>> v;
    for(unsigned i = 0; i < 3; ++i) {
        std::vector<int> vi;
        v.push_back(vi);
    }
    typedef std::vector<std::vector<int>> nested;
    typedef std::vector<int> cont;
    std::copy(arr[0], arr[2] + 3, nested_back_inserter<nested, cont, 3>(v));
    for(auto it = v.begin(); it != v.end(); ++it) {
        std::cout << "{";
        for(auto it2 = it->begin(); it2 != it->end(); ++it2) {
                std::cout << *it2 << ", ";
        }
        std::cout << "}n";
    }
    return 0;
}

特别注意std::copy(arr[0], arr[2] + 3, ...);中的丑陋。

由于疲劳，我不承担任何off-by- 1错误或其他奇怪的可能发生在这个。它应该给你一个如何实现这样的东西的想法。

您必须编写自己的迭代器，它在解引用时产生一个helper对象，该对象在赋值时将一维数组复制到具有std::copy的向量(并且为了向相反方向复制，另一个迭代器执行相反的操作)。基本上，看看back_insert_iterator是如何实现的，并做几乎相同的事情，只是代替push_back调用std::copy。

我个人认为不值得。我只是使用for循环的外部副本。你已经有了一个，只需将std::copy添加到它的主体，就在resize之后。

注意，如果你事先resize你的向量，你不需要std::back_inserter，因为它会分配更多的存储空间。使用begin代替。

相关文章：