Question

如何将3d指针记忆到另一个3d？我已经尝试了以下内容：

void somefunction(ArrayBlock **** b1, int noOfBlocks, ArrayBlock **** b2){  
   memcpy((&b2), (&b1), noOfBlocks*sizeof(ArrayBlock));
}

这在gdb中给出了以下错误：

[Inferior 1 (process 8528) exited with code 030000000005]

b1和b2都在主函数中分配了内存，如下所示：

ArrayBlock ***b2;
b2 = malloc(max_x * sizeof(ArrayBlock **));
for (i = 0; i < max_x; ++i)                             
{
    b2[i] = malloc(max_y * sizeof(ArrayBlock *));
    for (j = 0; j < max_y; ++j)
    {
        b2[i][j] = malloc(max_z* sizeof(ArrayBlock));
    }
}

解决方案：

我认为因为我的3D指针（数组）的初始化是不连续的，所以一个memcpy是不够的。

所以这就是我所做的：

int i2, j2;
for(i2 = 0; i2 < max_x; i2++){
  for(j2 = 0; j2 < max_y; j2++){
    memcpy(&(*b2)[i2][j2][0], &(*b1)[i2][j2][0], max_z*sizeof(ArrayBlock));
  }
}

我认为这次它真实有效，感谢那些帮助过我的人。

Answer 1

这取决于你的3D数组的分配方式，但在最常见的情况下（数组数组的数组）答案是否定的。

是一种以可能的方式分配3D数组的方法，但是：

分配单个CX * CY * CZ数组（Stuff* pXyz）
为Stuff（Stuff** ppXy）
使用指向pXyz（ppXy[x*CY + y] = &pXyz[x*CY*CZ + y*CZ + 0];）
分配指向Stuff指针的单个CX指针数组（Stuff*** pppX）
使用指向ppXy（pppX[x] = &ppXy[x*CY + 0];）
return pppX;

我希望我没有弄错，但这是基本想法：一个维度，一个malloc。

Stuff*** Alloc3DArray(size_t cx, size_t cy, size_t cz) {
    Stuff*** ret = NULL;

    /*Allocate a single CX*CY*CZ array of Stuffs*/
    Stuff* pXyz = malloc(cx * cy * cz * sizeof(*pXyz));
    if(pXyz!=NULL) {
        /*Allocate a single CX*CY array of pointers to Stuff*/
        Stuff** ppXy = malloc(cx * cy * sizeof(*ppXy));
        if(ppXy!=NULL) {
            /*Allocate a single CX array of pointers to pointers to Stuff*/
            Stuff*** pppX = malloc(cx * sizeof(*pppX));
            if(pppX!=NULL) {

                /*Initialize ppXy with pointers to various areas of pXyz*/
                size_t x, y;
                for(x=0 ; x<cx ; x++){
                    for(y=0 ; y<cy ; y++){
                        ppXy[x*cy + y] = &pXyz[x*cy*cz + y*cz + 0];
                    }
                }

                /*Initialize pppX with pointers to various areas of ppXy*/
                for(x=0 ; x<cx ; x++){
                    pppX[x] = &ppXy[x*cy + 0];
                }

                /*Success!*/
                ret = pppX;
            } else {
                /*Allocating third level failed: free first and second levels*/
                free(ppXy), ppXy=NULL;
                free(pXyz), pXyz=NULL;
            }
        } else {
            /*Allocating second level failed: free first level*/
            free(pXyz), pXyz=NULL;
        }
    }
    return ret;
}

有了这个，你可以记住这个：

memcpy(&pppDest[0][0][0], &pppSource[0][0][0], CX*CY*CZ*sizeof(***pppDest));

已添加：当您完成数组操作后，如果您已完成此操作，则可以将其释放：

void Free3DArray(Stuff ***pppArr) {
    if(pppArr != NULL) {
        free(**pppArr); /*Free third level*/
        free( *pppArr); /*Free second level*/
        free(  pppArr); /*Free first level*/
    }
}

记住c中的3d指针

1 个答案: