Reserving a bit for discriminating the type of a union in C++

I currently have code that looks like this:

union {
    struct {
        void* buffer;
        uint64_t n : 63;
        uint64_t flag : 1;
    } a;

    struct {
        unsigned char buffer[15];
        unsigned char n : 7;
        unsigned char flag : 1;
    } b;
} data;

It is part of an attempted implementation of a data structure that does small-size optimization. Although it works on my machine with the compiler I am using, I am aware that there is no guarantee that the two flag bits from each of the structs actually end up in the same bit. Even if they did, it would still technically be undefined behavior to read it from the struct that wasn't most recently written. I would like to use this bit to discriminate between which of the two types is currently stored.

Is there a safe and portable way to achieve the same thing without increasing the size of the union? For our purpose, it can not be larger than 16 bytes.

If not, could it be achieved by sacrificing an entire byte (of n in the first struct and of buffer in the second), instead of a bit?