Using memcpy for copying array to struct and vice versa in C

Question

Suppose I have structure:

typedef struct {
double re;
double im;
}ComplexStruct;

and array:

typedef double ComplexArr[2];// [0] -> real, [1] -> imag

today I am copying from ComplexStruct to ComplexArr and vice versa using simple for loop:

//ComplexArr to  ComplexStruct
for (i = 0 ; i < NumEl; i++)
{
     ComplexStructVec[i].re = ComplexArrVec[i][0];
     ComplexStructVec[i].im = ComplexArrVec[i][1];
}

//ComplexStruct to ComplexArr
for (i = 0 ; i < NumEl; i++)
{
     ComplexArrVec[i][0] = ComplexStructVec[i].re;
     ComplexArrVec[i][1] = ComplexStructVec[i].im;
}

Is there a way to this safely using memcpy for at least one of the directions? Is there another way which will by faster than for loop?

Answer 1

The optimizer in your compiler should do a great job with that code, you don't need to change much to make it optimal. However, if you are passing ComplexStructVec and ComplexArrVec into a function, you should mark them as restrict so the compiler knows there is no aliasing going on. Like this:

void copy(ComplexStruct* restrict ComplexStructVec, const ComplexArr* ComplexArrVec)
{
    unsigned NumEl = 1000;
    for (unsigned i = 0 ; i < NumEl; i++)
    {
        ComplexStructVec[i].re = ComplexArrVec[i][0];
        ComplexStructVec[i].im = ComplexArrVec[i][1];
    }
}

By doing that you eliminate a whole bunch of generated code because it doesn't need to handle the possibility that the two arguments overlap.

Demo: https://godbolt.org/z/F3DUaq (just delete "restrict" there to see the difference). If NumEl is less than 18 it will unroll the whole thing into one load and one store per iteration.

Answer 2

Yes, you can use memcpy, with a few caveats:

1. The layout of the array and structure are identical, meaning that the compiler does not align either the items in the array or entries in the structure.
2. The memory associated with the struct and array are identical in size.
3. You are not concerned with portability to other architectures (which may change the answers to #1 and/or #2).
4. This is not an ideal programming technique as it has some potential pitfalls, as noted above).

If after the above you still want to do this, the following code should do the trick:

/* NOTE: sizeof(ComplexStructVec) === sizeof(ComplexArrVec) */
memcpy((void *) ComplexStructVec,
       (void *) ComplexArrVec,
       sizeof(ComplexStructVec)*NumEl);

What this does is, since you are using vectors (arrays) in both cases, you have the address of them by using just their names. memcpy defines the destination and source addresses as void *, so I cast the arguments. The number of bytes to copy is the size, in bytes, of the structure or array (see NOTE) times the number of entries in the vector. The (void *) cast may not be required. It depends upon the compiler, the language standard level, and other compile time qualifiers.

Also note, I intentionally did not have a place for the return value, which is a pointer to the destination. If you want this information, be careful, as saving it to ComplexStructVec may cause either compiler (or worse case run-time) issues, depending on how it was allocated (by the compiler or during run-time).

A more complete example:

void copy(ComplexStruct* ComplexStructVec, ComplexArr* ComplexArrVec)
{
    unsigned NumEl = 1000;
    memcpy(ComplexStructVec, ComplexArrVec, sizeof(ComplexStruct)*NumEl);
}

Answer 3

The most portable way is the loops as in your example. This is sometimes referred to as serializing/de-serializing of the struct.

The problem with structs is that they aren't guaranteed to have a consistent memory layout, like arrays are. To dodge alignment problems, the compiler is free to add padding bytes anywhere. In case of a struct consisting of nothing but 8 byte double, padding is highly unlikely. But still, formally it isn't portable.

You can however fairly safely do the following:

_Static_assert(sizeof(ComplexStruct) == sizeof(double[2]), 
                 "Weird systems not supported");

ComplexStruct cs;
double arr[2];
memcpy(&cs, arr, sizeof arr);
memcpy(arr, &cs, sizeof arr);

This is "reasonably portable" to all real-world systems.

Another option is to give the struct two different variable representations by adding a union, like this:

typedef union {
  struct // C11 anonymous struct
  {
    double re;
    double im;
  };
  double arr[2];
}ComplexStruct;

The inner struct may still have padding, so you should add a formal static assert still. But this allows you the flexibility to use the data contents either as individual members or as an array.

And finally, C actually has language support for complex numbers. double _Complex is standard C, and complex.h is a standardized complex library. See How to work with complex numbers in C?