C++ 对多维数组使用复制

我只是想更多地了解stl语义，并在适当的地方将旧循环转换为算法。我很难找到将此循环转换为复制调用的最佳方法。有什么想法吗

    vector< vector<float> > rvec;
    const float * r[Max] = ...;

    // ...

    for (int ri=0; ri<N; ri++)
      for (int rj=0; rj<M; rj++)
        rvec[ri][rj] = r[ri][rj];

vectorrvec；
常量浮点*r[Max]=。。。；
// ...
对于（int ri=0；ri不确定只使用标准算法而不使用函子就可以做到这一点（使用这些算法，代码必然会比上面显著增长）

你知道，有时候一个简单的循环是最好的。STL的算法非常好，但是因为C++没有匿名函数或者内置lambda（还）。，获取上面显示的完全可读的代码并将其转换为STL算法更像是一种智力练习，而不是实际的改进，
不确定仅使用标准算法而不使用函子就可以做到这一点（有了这些，代码必然会比上面显著增长）

rvec.resize(Max);
for (int i = 0; i < Max; ++i) {
  rvec[i].resize(M);
  std::copy(r[i], r[i] + M, rvec[i].begin());
}

你知道，有时候一个简单的循环是最好的。STL的算法非常好，但是因为C++没有匿名函数或者内置LAMBDAS（还没有），所以使用上面所示的完全可读代码并将其转换成STL算法比实际的改进更像是一种智力练习，
 <代码> RVEC。
rvec.resize(Max);
for (int i = 0; i < Max; ++i) {
  rvec[i].resize(M);
  std::copy(r[i], r[i] + M, rvec[i].begin());
}

对于（int i=0；i

如果

rvec

本身和

rvec

中的每个向量已经具有正确的大小，则不需要调整大小。

rvec.resize（Max）；
对于（int i=0；i

---

<> > <代码> RVEC 本身和每个代码在Reave>RVEC 中已经有正确的大小，不需要调整大小。在这种情况下，

虽然只留下代码不是很坏。但是如果你多次编写它，将它抽象成一个单独的函数将是个好主意。另一点要考虑的是，任何不保存O的解决方案。R调整大小会浪费你不需要拷贝的时间。

在这种情况下，只留下代码并不是那么糟糕。虽然如果你多次编写它，将它抽象成一个单独的函数将是个好主意。另一个要考虑的问题是，任何不保留或调整大小的解决方案都会浪费你不需要拷贝的时间。

这是我用迭代器快速制作的一个例子

#include <algorithm>
using std::copy;
using std::for_each;
using std::random_shuffle;

#include <iostream>
using std::cout;
using std::endl;

#include <vector>
using std::iterator;
using std::vector;

void Write(int i)
{
    cout << i << endl;
}

int main()
{
    const short MAX_LIST = 1000,
                MAX_NUMBER = 100;
    float number = 0;
    vector<vector<float> > v (MAX_LIST),
                           v2 (MAX_LIST);
    vector<float> list(MAX_NUMBER);

    //Fills list and fills v with list
    for(vector<vector<float> >::iterator v_iter = v.begin(); v_iter != v.end(); ++v_iter)
    {
        for(vector<float>::iterator list_iter = list.begin(); list_iter != list.end(); ++list_iter)
        {
            *list_iter = number;
            ++number;
        }
        *v_iter = list;
    }

    //write v to console
    for(vector<vector<float> >::iterator v_iter = v.begin(); v_iter != v.end(); ++v_iter)
    {
        for_each(v_iter->begin(), v_iter->end(), Write);
    }

    //copy v to v2
    cout << "Copying..." << endl;
    copy(v.begin(), v.end(), v2.begin());
    cout << "Finished copying!" << endl;

    cout<< "Shuffling..." << endl;
    random_shuffle(v2.begin(), v2.end());
    cout << "Finished shuffling!" << endl;

    //write v2 to console
    for(vector<vector<float> >::iterator v_iter = v2.begin(); v_iter != v2.end(); ++v_iter)
    {
        for_each(v_iter->begin(), v_iter->end(), Write);
    }
}

#包括
使用std：：copy；
使用std:：for_；
使用std:：random_shuffle；
#包括
使用std：：cout；
使用std：：endl；
#包括
使用std：：迭代器；
使用std：：vector；
无效写入（int i）
{
cout end（），Write）；
}
//将v复制到v2
cout这是我用迭代器快速制作的一个示例

#include <algorithm>
using std::copy;
using std::for_each;
using std::random_shuffle;

#include <iostream>
using std::cout;
using std::endl;

#include <vector>
using std::iterator;
using std::vector;

void Write(int i)
{
    cout << i << endl;
}

int main()
{
    const short MAX_LIST = 1000,
                MAX_NUMBER = 100;
    float number = 0;
    vector<vector<float> > v (MAX_LIST),
                           v2 (MAX_LIST);
    vector<float> list(MAX_NUMBER);

    //Fills list and fills v with list
    for(vector<vector<float> >::iterator v_iter = v.begin(); v_iter != v.end(); ++v_iter)
    {
        for(vector<float>::iterator list_iter = list.begin(); list_iter != list.end(); ++list_iter)
        {
            *list_iter = number;
            ++number;
        }
        *v_iter = list;
    }

    //write v to console
    for(vector<vector<float> >::iterator v_iter = v.begin(); v_iter != v.end(); ++v_iter)
    {
        for_each(v_iter->begin(), v_iter->end(), Write);
    }

    //copy v to v2
    cout << "Copying..." << endl;
    copy(v.begin(), v.end(), v2.begin());
    cout << "Finished copying!" << endl;

    cout<< "Shuffling..." << endl;
    random_shuffle(v2.begin(), v2.end());
    cout << "Finished shuffling!" << endl;

    //write v2 to console
    for(vector<vector<float> >::iterator v_iter = v2.begin(); v_iter != v2.end(); ++v_iter)
    {
        for_each(v_iter->begin(), v_iter->end(), Write);
    }
}

#包括
使用std：：copy；
使用std:：for_；
使用std:：random_shuffle；
#包括
使用std：：cout；
使用std：：endl；
#包括
使用std：：迭代器；
使用std：：vector；
无效写入（int i）
{
cout end（），Write）；
}
//将v复制到v2
我不能同意。仅仅为了使用STL的copy（）而到处乱扔迭代器是不值得的，因为你已经有了同样可以完成这项工作的代码。匿名Lambda是c++0x标准的一部分，目前的编译器已经支持其中的大部分。也许值得一试，看看它是否有效。我不同意。。。STL库经过了真正的优化，使用迭代器也使代码在性能方面变得更好。你们在这里所说的几乎就像是说，比起聪明和深思熟虑的代码，你们更喜欢编写蹩脚的代码。@Partial:我同意，除了（a）他说的是接受一堆工作代码并对其进行更改，这会带来引入bug的风险，以及（b）没有lambdas，新代码的可读性无可否认会降低。就性能而言，两者几乎肯定是相同的——copy（）调用可以更快的唯一方法是，如果库实现以某种方式将工作分散到多个CPU上，就我所知，目前没有任何库实现能够做到这一点。不过，这可能会成为将来选择copy（）的一个令人信服的理由。@j_random_hacker:如果您正在更改工作代码，肯定会导致一些bug。所以，当您在使用STL时，为什么不花时间使用STL呢？STL实际上可以减少代码。。。您可以使用一条直线将一个向量复制到另一个向量，而不是使用两个循环。我不明白为什么代码会变得不那么可读。无论如何，如果有一些复杂的代码，你应该留下注释来解释代码的作用！同意。仅仅为了使用STL的copy（）而到处乱扔迭代器是不值得的，因为你已经有了同样可以完成这项工作的代码。匿名Lambda是c++0x标准的一部分，目前的编译器已经支持其中的大部分。也许值得一试，看看它是否有效。我不同意。。。STL库经过了真正的优化，使用迭代器也使代码在性能方面变得更好。你们在这里所说的几乎就像是说，比起聪明和深思熟虑的代码，你们更喜欢编写蹩脚的代码。@Partial:我同意，除了（a）他说的是接受一堆工作代码并对其进行更改，这会带来引入bug的风险，以及（b）没有lambdas，新代码的可读性无可否认会降低。就性能而言，两者几乎肯定是相同的——copy（）调用可以更快的唯一方法是，如果库实现以某种方式将工作分散到多个CPU上，就我所知，目前没有任何库实现能够做到这一点。不过，这可能会成为将来选择copy（）的一个令人信服的理由。@j_random_hacker:如果您正在更改工作代码，肯定会导致一些bug。所以，当您在使用STL时，为什么不花时间使用STL呢？STL实际上可以减少代码。。。您可以使用一条直线将一个向量复制到另一个向量，而不是使用两个循环。我不明白为什么代码会变得不那么可读。不管怎样，如果你有一些复杂的代码