Compiler Explorer

Source code

// public declaration

// this is a shell type.
// real definition lies within the unit.
// `meters` is a POD type, and be copied.
// `meters` can also be initialized with `memset()`
#define METERS_SIZE 8
typedef union {
    char body[METERS_SIZE];
    unsigned align4;   // ensures `meters` is aligned on 4-bytes boundaries
} meters;

meters meters_init(int i);
meters meters_add(meters a, meters b);

// within unit

#include <string.h>   // memset
#include <assert.h>   // static_assert

typedef enum { just, an, example } tag;
typedef struct {
    int m;
    tag t;
} meters_internal;
// ensure shell type is large enough
static_assert(sizeof(meters) >= sizeof(meters_internal), "meters shell type is too small");

// Don't alias pointers of different types.
// shell and internal types are different !
meters meters_init_byref_incorrect(int i)
{
    meters r;
    meters_internal* mptr = (meters_internal*)&r; // using a pointer in the hope to save one memory space
    mptr->m = i;
    mptr->t = example;
    return r;  // notice the compiler believes that r is potentially uninitialized
               // because operations on mptr are not tracked as impacting r
               // since mptr and &r have different types.

// In the end, it still generates correct output (see assembly on right pane), 
    // but it's invitation for troubles, more complex cases might not work so well.
}

// Use memcpy to safely transport data
// from shell to internal type, and vice versa.
meters meters_init_memcpy_correct(int i)
{
    meters_internal m;
    m.m = i;
    m.t = example;

meters r;
    memcpy(&r, &m, sizeof(m));  // don't worry, the compiler will be clever enough to avoid this memcpy
    return r;
}