memcpy() for variable dimensions of a 3D array - c

Question

I have a function concat to concatenate the matrix mat1 to form mat2. Here mat1 and mat2 uses fixed dimensions (i.e DIM1 = 2, DIM2 = 2, DIM3 = 3, DIM1_1 = 4) but in practice I need them to be of variable dimensions, so I declared the size of 3d array to max size as commented in my code below (i.e DIM2 = 20, DIM3 = 30) but the program gives garbage value when I do this. Could someone please advise on how to use variable sized 3d arrays without using malloc() ?
#include <stdio.h>
#include <string.h>
//!< Dimensions of a 3d array
#define DIM1 2
#define DIM2 2
#define DIM3 3
#define DIM1_1 4
void Concat(int (*mat1)[DIM2][DIM3], int (*mat2)[DIM2][DIM3], int len);
// void Concat(int (*mat1)[20][30], int (*mat2)[20][30], int len);
int main()
{
int mat1[DIM1][DIM2][DIM3] = {{{1,2,3},{4,5,6}},{{1,2,3},{4,5,6}}};
int mat2[DIM1_1][DIM2][DIM3];
Concat(mat1,mat2,2);
return 0;
}
// void Concat(int (*mat1)[20][30], int (*mat2)[20][30], int len){
void Concat(int (*mat1)[DIM2][DIM3], int (*mat2)[DIM2][DIM3], int len){
/*concatenate mat1 to mat2 */
memcpy(mat2[0], mat1, DIM1*DIM2*DIM3 * sizeof mat1);
memcpy(mat2[0+len], mat1, DIM1*DIM2*DIM3 * sizeof mat1);
}

Answer 1

I declared the size of 3d array to max size as commented in my code below (i.e DIM2 = 20, DIM3 = 30) but the program gives garbage value when I do this.
And I hope that before getting garbage values at runtime, your compiler warned you about the type mismatch that you created that way. If it didn't, then you would be well served by figuring out how to turn up the warning level, or else by choosing a more helpful compiler.
Either way, the parameters to your Concat() function are pointers to 2D arrays of specific dimensions. If the actual arguments are pointers to something else, even arrays of different dimension, then it should not come as a surprise that the results are poor. In fact, this produces a violation of the so-called "strict aliasing rule", and the behavior is therefore undefined.
Could someone please advise on how to use variable sized 3d arrays without using malloc() ?
I interpret you to mean you want a single function that works for arrays of various dimensions, not that any individual array has dimensions that change over time. There are several things you can do, but here are some good alternatives:
If your implementation supports VLAs (mandatory in C99, but optional since C11) then you can use them to support your Concat() function. This kind of thing is one of my favorite uses for VLAs, inasmuch as it sidesteps the biggest practical concern with their usage, which revolves around space available for their automatic allocation. Such an approach might look like this:
void Concat(size_t dim1, size_t dim2, size_t dim3 int (*source)[dim2][dim3],
int (*dest)[dim2][dim3]) {
size_t source_size = dim1 * sizeof(*source);
memcpy(dest, source, source_size);
memcpy(dest + dim1, source, source_size);
}
You will note that this requires you to pass all the dimensions of the source array as separate arguments, and that all dimensions but the first match for the two arrays. You would use that pretty simply:
int mat1[DIM1][DIM2][DIM3] = /* ... */
int mat2[DIM1 * 2][DIM2][DIM3];
Concat(DIM1, DIM2, DIM3, mat1, mat2);
Of course, you can use the same function, in the same program, to concatenate pairs of arrays of various dimensions, provided the constraints already described are satisfied.
If you cannot or do not want to rely on VLAs, then your best alternative might be simply to adapt the above to that case, like so:
void Concat(size_t dim1, size_t dim2, size_t dim3, void *source, void *dest) {
size_t source_size = dim1 * dim2 * dim3 * sizeof(int);
memcpy((char *) dest, source, source_size);
memcpy((char *) dest + source_size, source, source_size);
}
You could call that function the same way as the previous.
If you want to be even more general, and at the same time provide a simpler function signature, you could convert the above to concatenate arbitrary objects:
void Concat(size_t source_size, void *source, void *dest) {
memcpy((char *) dest, source, source_size);
memcpy((char *) dest + source_size, source, source_size);
}
This achieves complete generality by putting responsibility on the caller for computing and passing the size of the source object, in bytes, though that's not necessarily a big problem. For example,
int mat1[DIM1][DIM2][DIM3] = /* ... */
int mat2[DIM1 * 2][DIM2][DIM3];
Concat(sizeof(mat1), mat1, mat2);

Answer 2

I'm sorry, but it cannot be done (without knowing the maximum length in advance). When your function makes mat1, it reserves precisely 2*2*3 ints-worth of memory on the stack for the array, and sticks each sub-array right next to each other. If statically allocated, there's no way to change this after it's been done.
However... with dynamic memory allocation (i.e. malloc and friends) it's possible to do this. Specifically, using realloc to allocate extra space.
Sorry.