CS and DS do not need a type member. Whenever CS and DS are being used directly, the code using them already knows what they are. Only ignorant code inspecting the union needs access to a type flag.

An unrequired additional member needlessly increases storage requirements. The additional member changes the ABI, which could be an issue if backward compatibility is relevant (probably not in this case) and if any instances of these objects have been serialized.

Any structs that may be added to the union in the future will need to adhere to this format.

The redundancy is obvious when you consider that with a type member introducing every struct, you don't need the union at all. You can just cast to int, pass that, check the value, and then cast to either DS or CS. It's not even especially ugly.

Code:

void myfunc(int *type)
{
        CS *c;
        DS *d;

        switch(*type) {
        case TYPE_DS:
                d = (DS *) type;
                d->dc=0;
                d->dd=0;
                break;
        case TYPE_CS:
                c = (CS *) type;
                c->cc=0;
                break;
        }
}

myfunc((int *) &mycs);
myfunc((int *) &myds);

Or if you do keep the union, the type member, which is barely more than a decoration, could be eliminated:

Code:

typedef union S {
        DS ds;
        CS cs;
} S;

void myfunc(S *data)
{
        switch(data->ds.type) {  /* even if the current member is cs, this is not an error */ 
        case TYPE_DS:
                data->ds.dc=0;
                data->ds.dd=0;
                break;
        case TYPE_CS:
                data->cs.cc=0;
                break;
        }
}

The redundancy which allows for these alternatives is a strong hint that there's a simpler way. I would suggest using a tagged union and leaving the initial structs as they were:

Code:

typedef struct US {
        int type;
	union {
		DS ds;
		CS cs;
	} s;
} US;

Regards,
Alister