Question

我正在编写一个程序，需要使用一个非常原始的（至少是我的新体验）一系列的整数。它应该看起来像： my_array [A] [B] [C] [d]

a从0到N_CORES-1，其中N_CORES是正在运行的机器上的CPU核心数，并且从头开始由open-mp定义。

c，d取0到ARG之间的值，ARG是用户传递的行参数

但是b需要在0和值之间运行，具体取决于a（每个核心都不一样）。

我尝试使用带有循环的new分配器创建此对象：

for(int i =0;i < N_CORES; i++){
    my_array[i] = new int**[size_for_i];

但我稍后会遇到段错误。是因为它不是定义这些锯齿状数组的正确方法吗？我应该使用载体吗？我从来没有用矢量做过四维的事情，所以我有点迷失它。

编辑：实际上我决定用另一种方式实现它，只有一个＆＃34;只有＆＃34; 3d，合并我前一个对象的两个第一个索引。尽管如此，仍然有很多建议！

Answer 1

试试这个：

int ***my_array[N_CORES];
for(int a = 0; a < N_CORES; a++)
{
    my_array[a] = new int**[size_for_a];
    for( int b = 0; b < size_for_a[a]; b++)
    {
        my_array[a][b] = new int*[ARG];
        for( int c = 0; c < ARG; c++)
        {
             my_array[a][b][c] = new int[ARG];
        }
    }
}

Answer 2

将数据分成不同级别可能更容易。在每个级别定义重载的operator []函数以提供语法糖。

struct Level1Data
{
   int& operator [](int i) {return d[i];}
   int* d;
};

struct Level2Data
{
   Level1Data& operator [](int i) {return c[i];}

   Level1Data* c;
};

struct Level3Data
{
   Level2Data& operator [](int i) {return b[i];}

   Level2Data* b;
};

struct Level4Data
{
   Level3Data& operator [](int i) {return a[i];}

   Level3Data* a;
};

void foo()
{
   Level4Data myinfo;
   int k = myinfo[0][4][3][10];
};

根据presius litel snoflek的建议，对数据采用递归模板方法。

template <int Level, typename Data>
struct MemberData
{
   MemberData<Level-1, Data>& operator [](int i) {return data[i];}
   MemberData<Level-1, Data>* data;
};

template <typename Data>
struct MemberData<0, Data>
{
   Data& operator [](int i) {return data[i];}
   Data* data;
};

void bar()
{
   MemberData<3, int> myinfo;
   int k = myinfo[0][4][3][10];
};

C ++ - 参差不齐的4d数组

2 个答案: