2

如何将 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 都在 main 函数中分配了内存，如下所示：

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));
  }
}

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

4

1 回答 1

1

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

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

  • 分配单个 CX*CY*CZ 数组的 Stuffs ( Stuff* pXyz)
  • 将单个 CX*CY 指针数组分配给 Stuff ( Stuff** ppXy)
  • pXyz用指向( ppXy[x*CY + y] = &pXyz[x*CY*CZ + y*CZ + 0];)的各个区域的指针对其进行初始化
  • 将单个 CX 指针数组分配给指向 Stuff ( 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这个：

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*/
    }
}
于 2013-10-04T18:46:11.700 回答