Casting pointer to struct to pointer to struct with const member

Question

Imagine that you have such structs:

struct nix_codec {
    nix_uint8 state;
    nix_uint8 mode;
    nix_uint8 flags;
    nix_size offset;
    nix_uint32 codepage;
    nix_utf8 const *const *aliases;
    void (*delete)(
        struct nix_codec *codec,
        struct nix_error *error
    );
    struct nix_codec* (*clone)(
        struct nix_codec const *codec,
        nix_int8 mode,
        struct nix_error *error
    );
    nix_size (*decode)(
        struct nix_codec *codec,
        nix_byte const *bdata,
        nix_size bsize,
        nix_rune *udata,
        nix_size usize,
        struct nix_error *error
    );
    nix_size (*encode)(
        struct nix_codec *codec,
        nix_rune const *udata,
        nix_size usize,
        nix_byte *bdata,
        nix_size bsize,
        struct nix_error *error
    );
};

typedef struct {
    nix_uint8 const state;
    nix_uint8 const mode;
    nix_uint8 const flags;
    nix_size const offset;
    nix_uint32 const codepage;
    nix_utf8 const *const *const aliases;
} nix_codec;

One has also several functions, which are used to create the nix_codec* instances, e.g. for UTF-8 codec it will look like this:

static nix_size self_decode
(
    struct nix_codec *codec,
    nix_byte const *bdata,
    nix_size bsize,
    nix_rune *udata,
    nix_size usize,
    struct nix_error *error
)
{ /* UTF-8 decode function, too long to post here */}

static nix_utf8 const *const aliases[] = {
    "UTF-8",
    "UTF8",
    "CP65001",
    NULL,
};

nix_codec *nix_codec_utf8
(
    nix_int8 mode,
    struct nix_error *error
)
{
    struct nix_codec *codec = NULL;

    if ((mode != NIX_CODEC_STRICT) && (mode != NIX_CODEC_ESCAPE)
    &&  (mode != NIX_CODEC_REPLACE) && (mode != NIX_CODEC_IGNORE)) {
        return NULL;
    }
    codec = calloc(1, sizeof(struct nix_codec));
    if (codec == NULL) {
        return NULL;
    }
    codec->mode = mode;
    codec->codepage = 65001;
    codec->aliases = aliases;
    codec->decode = &self_decode;
    codec->encode = &self_encode;
    codec->flags = (NIX_CODEC_COMPATIBLE | NIX_CODEC_MULTIBYTE | NIX_CODEC_ABSOLUTE);
    return (nix_codec*)codec;
}

The function for legacy single-byte encodings is based on such structures:

struct nix_sbmap {
    nix_uint8 byte;
    nix_rune rune;
};

struct nix_sbcodec {
    struct nix_codec base;
    struct nix_sbmap const *entries;
    nix_size count;
};

Note that struct nix_sbcodec and struct nix_sbmap are declared in the source files, not in headers, thus there is no need to use variant pattern. The corresponding function, e.g. nix_codec_koi8r(), allocates a struct nix_sbcodec, sets its base, entries and count members and then casts it to nix_codec and returns it. Every actual encode() and decode() calls are performed using this public function:

nix_size nix_codec_decode
(
    nix_codec *codec,
    nix_byte const *bdata,
    nix_size bsize,
    nix_rune *udata,
    nix_size usize,
    struct nix_error *error
)
{
    nix_size result = 0;
    struct nix_codec *self = (struct nix_codec*)codec;

    return self->decode(self, bdata, bsize, udata, usize, error);
}

Note that state, mode, flags and offset members may be interesting to anyone using any codec (the most part of them is set in codec creator functions, offset is changed after calls to encode() and decode() functions and represents the count of bytes/Unicode characters which were successfully processed before function exited. Each codec has its own encode() and decode() functions as you see.

Now the question: is this trick correct and guaranteed to work by the C Standard?

Thanks in advance!

Answer 1

A reliable way of dealing with variant types in C, such as what I think you are attempting, is to use a union. For example:

typedef struct {
    uint8_t x;
    uint16_t y;
} obj_a;

typedef struct {
    char *p;
    char buf[42];
} obj_b;

typedef struct obj_base_s {
    int (*internal_func)(struct obj_base_s *, int);
    union {
         obj_a a;
         obj_b b;
    } u;
} obj_base;

All the creator / destructor functions will return or use an obj_base. Functions that use members in the union can either access their bits directly else do something like this:

void handle_obja(obj_base *bp)
{
     obj_a *oap = &bp->u.a;
     oap->x = 23;
     oap->y = 19;
     ...
}

C is not C++, if you want nice classes, inheritance, overloading and all that stuff, then use C++. That is the main reason why C++ was invented. C does not do "classes". C is a much lower level language.

Answer 2

Note that state, mode, flags and offset members may be interesting to anyone using any codec (…

Now the question: is this trick correct and guaranteed to work by the C Standard?

However useful it may be and however often it may work, this trick (accessing members of a struct nix_codec object by a pointer to a differently defined nix_codec object) is unsafe unless you assert that the corresponding members of both structure types have respectively the same offset in the structures; this is not guaranteed for the independently defined structure types; such guarantee exists only within a union of the structures - see section Language / Expressions / Postfix operators / Structure and union members / paragraph 6:

One special guarantee is made in order to simplify the use of unions: if a union contains several structures that share a common initial sequence (see below), and if the union object currently contains one of these structures, it is permitted to inspect the common initial part of any of them anywhere that a declaration of the completed type of the union is visible. Two structures share a common initial sequence if corresponding members have compatible types (and, for bit-fields, the same widths) for a sequence of one or more initial members.