c++ - 初始化 3D 矢量的最有效方法是什么？

Question

我在 C++ 中有一个 3D 字符串向量：

vector<vector<vector<string>>> some_vector

我正在尝试找到一种快速的方法来为其分配内存。

我尝试使用以下两种不同的方法来定义它：

#include<vector>
#include<iostream>
#include<ctime>
using namespace std;

#define DIM1 100
#define DIM2 9
#define DIM3 120

int main()
{
    clock_t t1_start = clock();
    vector<vector<vector<string>>> vec1(DIM1, vector<vector<string>>(DIM2, vector<string>(DIM3)));
    clock_t t1_end = clock();
    double diff1 = (t1_end - t1_start) / double(CLOCKS_PER_SEC);

    clock_t t2_start = clock();
    vector<vector<vector<string>>> vec2;
    vec2.resize(DIM1);
    for(int i = 0; i < DIM1; i++)
    {
        vec2[i].resize(DIM2);
        for(int j = 0; j < DIM2; j++)
            vec2[i][j].resize(DIM3);
    }
    clock_t t2_end = clock();

    double diff2 = (t2_end - t2_start) / double(CLOCKS_PER_SEC);

    cout<<"1st definition used time: "<<diff1<<"s"<<endl;
    cout<<"2nd definition used time: "<<diff2<<"s"<<endl;
}

我希望第一种方法（vec1）可能比第二种方法（vec2）更快。

但事实证明，第一种方法比第二种方法慢得多。在我的机器上，第一种方法用了 0.245 秒，而第二种方法用了 0.152 秒。

此外，当我将数据类型切换为 int 时，第一个耗时 0.058 秒，第二个耗时 0.004。

我可以知道是什么导致了这种差异吗？有没有更好的方法来为 3D 矢量分配内存？

提前谢谢了。

Answer 1

我可以知道是什么导致了这种差异吗？

第一个版本通过复制 1-d 向量构造 2-d 向量，然后通过复制来构造 3-d 向量。这可能比在不复制的情况下调整向量的大小要慢。但是，如果您正在优化构建，我希望差异可以忽略不计。

有没有更好的方法来为 3D 矢量分配内存？

使用单个连续数组可能会更好，该数组包装在提供多维访问器的类中。这将使分配更加简单，并且在访问元素时也可以避免一些指针取消引用（以一些算术为代价）。像这样的东西：

template <typename T>
class vector3d {
public:
    vector3d(size_t d1=0, size_t d2=0, size_t d3=0, T const & t=T()) :
        d1(d1), d2(d2), d3(d3), data(d1*d2*d3, t)
    {}

    T & operator()(size_t i, size_t j, size_t k) {
        return data[i*d2*d3 + j*d3 + k];
    }

    T const & operator()(size_t i, size_t j, size_t k) const {
        return data[i*d2*d3 + j*d3 + k];
    }

private:
    size_t d1,d2,d3;
    std::vector<T> data;
};

Answer 2

我想我会通过分配一大块内存而不是很多小块来优化它。这个只是 2D 而不是 3D，但给出了基本思路：

template <class T>
class matrix { 
    size_t columns_;
    std::vector<T> data;
public:
    matrix(size_t columns, size_t rows) : columns_(columns), data(columns*rows) {}

    T &operator()(size_t column, size_t row) { return data[row*columns_+column]; }
};

对于 3D，您需要处理“平面”（或其他东西）以及行和列，但基本思想几乎相同。

Answer 3

我在 Mike Seymour 的代码中添加了一些功能，例如动态调整 3d 向量的大小以及对数据向量的访问/分配边界检查。

template <typename T>
class vector3d 
{
public:
    vector3d(size_t d1=0, size_t d2=0, size_t d3=0, T const & t=T()) :
        d1(d1), d2(d2), d3(d3), data(d1*d2*d3, t)
    {}

    T & operator()(size_t i, size_t j, size_t k) 
    {
            return (i<=d1 && j<=d2 && k<=d3) ? data[i*d2*d3 + j*d3 + k] 
                                             : data.at(i*d2*d3 + j*d3 + k);
    }

    T const & operator()(size_t i, size_t j, size_t k) const 
    {
        return data[i*d2*d3 + j*d3 + k];
    }

    void resize(const size_t _d1=0, const size_t _d2=0, const size_t _d3=0)
    {
        data.resize(_d1*_d2*_d3);
        d1=_d1;
        d2=_d2;
        d3=_d3;
    }

    void shrink_to_fit()
    {
        data.shrink_to_fit();
    }

    const size_t length() const
    {
        return data.size();
    }

    const size_t capacity() const
    {
        return data.capacity();
    }

    const size_t x() const
    {
        return d1;
    }

    const size_t y() const
    {
        return d2;
    }

    const size_t z() const
    {
        return d3;
    }


private:
    size_t d1,d2,d3;
    std::vector<T> data;
};

用法：

vector3d<int> vec3d(2,2,2,31); //create 2x2x2 3d vector and fill it with 31
vec3d(1,1,2)=45;               //assign 45 at vec3d(1,1,2)
vec3d.resize(2,2,1);           //resize the vec3d to 2x2x1
vec3d(1,2,2)=67;               //error (its out of bounds)

Answer 4

要初始化 3D 字符串向量，您应该为每个维度和每个索引一次初始化一个向量结构，例如：

  vector<vector<vector<string> > > myvector; //declare the 3D vector
  for(k=0; k<3; k++)
  {
    myvector.push_back(vector<vector<string> >()); //initialize the first index with a 2D vector
    for(i=0; i<4; i++)
    {
      myvector[k].push_back(vector<string>()); //initialize the 2 index with a row of strings
      for(j=0; j<4; j++)
      {
         result = " whatever you want to insert in the vector element";
         myvector[k][i].push_back(result); //fulfill the last index regularly
      } 
    }
  }

Answer 5

当您在第一种方法中初始化向量向量时，会分配一个临时向量，然后将所需次数复制到外部向量中。这意味着您有一个不必要的额外分配，并且新元素通过从另一个使用更多内存访问的数据结构复制它们的值来初始化。

按照第二种方法调整向量的大小更难看，但避免了额外的分配。此外，新元素由默认构造函数创建，不需要从其他向量复制。这也会更快。

如果速度很重要（也许它不重要，过早优化等等），那么您必须使用第二种方法（或其他答案建议的单块分配）。我不相信编译器可以简单地“优化”掉第一种方法的低效率。

Answer 6

这是向量的各种维度的示例，以防万一有人关心。我知道当我刚开始时，很难找到如何为多维向量赋予初始值，因为我找不到任何示例；

// This simple project demonstrates a single vector, a 2D vector, a 3D vector and a 4D vector in C++
//

#include <iostream>
#include <vector>



using namespace std;

int main ()
{
    vector<int> myVector = { 0,1,2,3,4,5,6 };
    vector<vector<int>> my2dVector = { {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20},{21,22,23,24,25},{0,-1,-2,-3,-4},{-6,7,22,-15,-25},{true,true,false,true,false} };
    vector < vector < vector<int>>> my3dVector =
    {
        {

            {1,2,3},
            {4,5,6},                // plane 0
            {7,8,9}
        },
        {
            {-1,-2,-3},
            {-4,-5,-6},             // plane 1
            {-10,-22,36}
        },
        {
            {129,212,999},
            {0,0,1},                // plane 2
            {false,true,false}
        }
    };
    vector<vector<vector<vector<int>>>> my4dVector =
    {
        {    //Cube 0
            {

                {1,2,3},
                {4,5,6},                // plane 0
                {7,8,9}
            },
            {
                {-1,-2,-3},
                {-4,-5,-6},             // plane 1
                {-10,-22,36}
            },
            {
                {129,212,999},
                {0,0,1},                // plane 2
                {false,true,false}
            }
        },
        {    //Cube 1
            {

                {10,2,-9},
                {44,55,60},                // plane 0
                {71,85,99}
            },
            {
                {-561,-6562,-453},
                {-14,-55,-76},             // plane 1
                {-110,-212,316}
            },
            {
                {729,812,456},
                {40,10,17},                // plane 2
                {true,true,false}
            }
        }
    };




    // 1D VECTOR..............
    cout << "This is a 1D vector of size " << myVector.size () << "\n";
    for (int i = 0; i < myVector.size (); i++)
    {
        cout << myVector[i] << "\t";
    }
    cout << "\n\n";



    // 2D VECTOR..............
    cout << "This is a 2D vector of size " << my2dVector.size () << " X " << my2dVector[0].size () << ".";
    if (my2dVector.size () == my2dVector[0].size ()) cout << "  This is a square matrix.";
    cout << "\n          ";
    for (int i = 0; i < my2dVector[0].size (); i++)
    {
        cout << "C" << i << "\t";
    }
    cout << endl;
    for (int i = 0; i < my2dVector.size (); i++)
    {
        cout << "Row: " << i << " -> ";
        for (int j = 0; j < my2dVector[i].size (); j++)
        {
            if (my2dVector[i][j] >= 0 && my2dVector[i][j] <= 9) cout << " ";

            cout << my2dVector[i][j] << "\t";
        }
        cout << endl;
    }
    cout << "\n\n";


    // 3D VECTOR.................
    cout << "This is a 3D vector of size " << my3dVector[0].size () << " X " << my3dVector[0][0].size () << " with " << my3dVector.size () << " planes.\n";
    for (int i = 0; i < my3dVector.size (); i++)
    {
        cout << "Plane #" << i << "\n";
        for (int j = 0; j < my3dVector[i].size (); j++)
        {
            for (int k = 0; k < my3dVector[i][j].size (); k++)
            {
                cout << my3dVector[i][j][k] << "\t";
            }
            cout << "\n";
        }

    }
    cout << "\n\n";


    //4D VECTOR.................
    cout << "This is a 4D vector of size " << my4dVector[0][0].size () << " X " << my4dVector[0][0][0].size () << " with " << my4dVector[0].size () << " planes and " << my4dVector.size () << " cubes.\n";
    for (int i = 0; i < my4dVector.size (); i++)
    {
        cout << "\nCUBE #"<< i<< " _________________\n";
        for (int j = 0; j < my4dVector[i].size (); j++)
        {
            cout << "Plane #" << j << "                |\n";
            for (int k = 0; k < my4dVector[i][j].size (); k++)
            {
                for (int l = 0; l < my4dVector[i][j][k].size (); l++)
                {
                    cout << my4dVector[i][j][k][l] << "\t";
                }
                cout << "|\n";
            }
            cout << "________________________|\n";
        }
        cout << "\n";
    }
    

}