函数中的C memcpy 2D数组到3D数组

Question

In the example below, I have a 3D array which I pass to a function, "fun", but only pass a "slice" of the 3D array ie a 2D array. Within the function, I have another 2D variable, which takes on some values within a double for loop. Before exiting the function, I need to copy the 2D temporary array to the "slice" of the 3D array. I tried the following, but my use of memcpy is "destroying" the original 3D array outside the function. What is the proper way to perform this operation?

void fun(double **array, int XDIM, int YDIM);   // Declaration

int main()
{
    double ***array
    int XDIM=10,YDIM=10,TDIM=2;

    allocate3d(&array,XDIM,YDIM,TDIM); // This works fine
    fun(array[0],XDIM,YDIM);

    //
    //  Other code note important to problem here
    //

    deallocate3d(array,XDIM,YDIM,TDIM); // This works fine
}


void fun(double **array, int XDIM, int YDIM)
{
    double **tmp;

    allocate2d(&tmp,XDIM,YDIM); // This works fine

    for(int j = 0; j < YDIM; j++)
    {
        for(int i = 0; i < XDIM; i++)
        {
            tmp[j][i] = 2.5;
        }
    }

    memcpy(array,tmp,XDIM*YDIM*sizeof(double));

    deallocate2d(tmp,XDIM,YDIM); // This works fine

}

EDIT: I want to add that "array" has dimensions of

array[TDIM][YDIM][XDIM]

and "tmp" has dimensions of

tmp[YDIM][XDIM]

I did address this in a comment, but thought I should point it out in the main question. I also showed that I free the memory of tmp within the function.

EDIT 2: I'm including the "allocate3D" and "deallocate3D" functions for further analysis of memory storage.

int allocate3D(double ****array, int XDIM, int YDIM, int TDIM)
{
    // Allocate 3rd dimension
    *array = calloc(TDIM,sizeof(double**));
    if (array==NULL)
    {
        printf("Error in memory allocation\n");
        return (EXIT_FAILURE);
    }

    // Allocate each 3rd dimensional pointer with array of pointers
    for(int i = 0; i < TDIM; i++)
    {
        (*array)[i] = calloc(YDIM,sizeof(double*));
    }

    if (array==NULL)
    {
        printf("Error in memory allocation\n");
        return (EXIT_FAILURE);
    }

    // Allocate remaining dimension
    for(int i = 0; i < TDIM; i++)
    {
        for(int j = 0; j < YDIM; j++)
        {
            (*array)[i][j] = calloc(XDIM,sizeof(double));
        }
    }

    if(array == NULL)
    {
        printf("Error in memory allocation\n");
        return(EXIT_FAILURE);
    }

    return 0;
}

---

void deallocate3D(double ***array, int XDIM, int YDIM, int TDIM)
{
    //  Deallocate each 3rd dimensional pointer
    for(int i = 0; i < TDIM; i++)
    {
        for(int j = 0; j < YDIM; j++)
        {
            free((array)[i][j]);
        }

        free((array)[i]);
    }

    // Deallocate 3rd dimension
    free(array);
}

The functions "allocate2D" and "deallocate2D" follow the same concept, minus the "TDIM" dimension, so I will leave it out for the sake of simplicity. It has been brought to my attention that the portion of the array which I'm trying to use with "memcpy" may not be contiguous and is "jagged". In addition to providing the allocation function, is there a simple way to identify contiguous memory storage? How do 3D arrays get stored in memory?

EDIT 3: I think I may have found a clue...in the example above, I'm setting YDIM == 1. I believe this affects the contiguous memory alignment and my allocation and free functions are causing errors. I've used Valgrind and it flags my allocation and free functions when YDIM == 1. In addition, this would affect how memcpy is behaving. Any thoughts on my speculations? Why set YDIM == 1....cause sometimes that is the case. I'm trying to keep things universal in application.

Answer 1

I think that what you want to do in fun is:

for(int j = 0; j < YDIM; j++)
{
    for(int i = 0; i < XDIM; i++)
    {
        array[j][i] = tmp[j][i];
    }
}

You cannot use a single memcpy because your array is not a contiguous bloc of memory; it is a jagged array (each 1-dimensional block is stored in a separate allocation).

I'm assuming you have your dimensions in the right order (you didn't post the body of allocate3d so that can't be verified)

Answer 2

I'm not sure you need a temp array there. Since you're already passing in the array itself, and in c you can modify arrays directly with other functions. Maybe...

void fun(double **array, int XDIM, int YDIM)
{
    for(int j = 0; j < YDIM; j++)
    {
        for(int i = 0; i < XDIM; i++)
        {
            array[j][i] = 2.5;
        }
    }
}

Let me know how it goes!