Safe union?

[Mogens Heller Jensen]

Hi group,

I wonder - can anybody tell me if it is safe to make a union like this:

union Event {
unsigned char charData[4];

struct {
unsigned int channel : 4;
unsigned int type : 4;
unsigned int note : 8;
int velocity : 8;
} fields;
};

- "safe" in the way that it is guaranteed that:
* fields.channel will return the 4 MSB of charData[0]
* fields.type will return the 4 LSB of charData[0]
* fields.note will return charData[1]
* fields.velocity will return charData[2]

Obviously, if I allocate the struct myself the compiler will guarantee that
no problems arise regarding alignment etc.

But what if the char data I am to interpret comes from "the framework" and I
have no idea where it is allocated? Imagine a function like this
(implementing a virtual framework function):

void interpretCharData(char *data) {
// will this give me problems?
Event *evt = (Event *)data;

// start using the bit fields of the struct here
}

And how about portability? I'm thinking alignment, endiannes, [insert
portability issue I do not know about yet here]

Thanks in advance!

Best regards,
Mogens

[Gianni Mariani]

Mogens Heller Jensen wrote:

Hi group,

I wonder - can anybody tell me if it is safe to make a union like this:

union Event {
unsigned char charData[4];

struct {
unsigned int channel : 4;
unsigned int type : 4;
unsigned int note : 8;
int velocity : 8;
} fields;
};

- "safe" in the way that it is guaranteed that:
* fields.channel will return the 4 MSB of charData[0]
* fields.type will return the 4 LSB of charData[0]
* fields.note will return charData[1]
* fields.velocity will return charData[2]
It is most certainly not guarenteed. This is implementation defined.
It may be this way on your particular platform, it may not.

Obviously, if I allocate the struct myself the compiler will guarantee that
no problems arise regarding alignment etc.

But what if the char data I am to interpret comes from "the framework" and I
have no idea where it is allocated? Imagine a function like this
(implementing a virtual framework function):

void interpretCharData(char *data) {
// will this give me problems?
Event *evt = (Event *)data;

// start using the bit fields of the struct here
}

And how about portability? I'm thinking alignment, endiannes, [insert
portability issue I do not know about yet here]

While there may still be implementation defined issues, this struct
might be more portable (I know of no compiler that would not do what you
specified).

#include <iostream>

class Event
{
unsigned char channel_n_type;

public:
unsigned char note;

signed char velocity;

unsigned channel()
{
return channel_n_type & 0xf;
}

unsigned channel( unsigned i_val )
{
channel_n_type = ( 0xf0 & channel_n_type ) | ( i_val & 0xf );
return i_val & 0xf;
}

unsigned type()
{
return ( channel_n_type & 0xf0 ) >> 4;
}

unsigned type( unsigned i_val )
{
channel_n_type = (0xf & channel_n_type) | (( i_val & 0xf )<<4);
return i_val & 0xf;
}
};

int main()
{
char x[3];

Event * e = reinterpret_cast<Event *>( x );

e->channel(2);
e->type(3);
e->note = 4;
e->velocity = 5;

std::cout << e->channel() << "\n";
std::cout << e->type() << "\n";
std::cout << int( e->note ) << "\n";
std::cout << int( e->velocity ) << "\n";

}

[Mogens Heller Jensen]

"Gianni Mariani" <gi*******@mariani.ws> wrote in message
news:s-********************@speakeasy.net...

Mogens Heller Jensen wrote:

Hi group,

I wonder - can anybody tell me if it is safe to make a union like this:

union Event {
unsigned char charData[4];

struct {
unsigned int channel : 4;
unsigned int type : 4;
unsigned int note : 8;
int velocity : 8;
} fields;
};

- "safe" in the way that it is guaranteed that:
* fields.channel will return the 4 MSB of charData[0]
* fields.type will return the 4 LSB of charData[0]
* fields.note will return charData[1]
* fields.velocity will return charData[2]

It is most certainly not guarenteed. This is implementation defined. It
may be this way on your particular platform, it may not.

Obviously, if I allocate the struct myself the compiler will guarantee
that no problems arise regarding alignment etc.

But what if the char data I am to interpret comes from "the framework"
and I have no idea where it is allocated? Imagine a function like this
(implementing a virtual framework function):

void interpretCharData(char *data) {
// will this give me problems?
Event *evt = (Event *)data;

// start using the bit fields of the struct here
}

And how about portability? I'm thinking alignment, endiannes, [insert
portability issue I do not know about yet here]

While there may still be implementation defined issues, this struct might
be more portable (I know of no compiler that would not do what you
specified).

#include <iostream>

class Event
{
unsigned char channel_n_type;

public:
unsigned char note;

signed char velocity;

unsigned channel()
{
return channel_n_type & 0xf;
}

unsigned channel( unsigned i_val )
{
channel_n_type = ( 0xf0 & channel_n_type ) | ( i_val & 0xf );
return i_val & 0xf;
}

unsigned type()
{
return ( channel_n_type & 0xf0 ) >> 4;
}

unsigned type( unsigned i_val )
{
channel_n_type = (0xf & channel_n_type) | (( i_val & 0xf )<<4);
return i_val & 0xf;
}
};

int main()
{
char x[3];

Event * e = reinterpret_cast<Event *>( x );

e->channel(2);
e->type(3);
e->note = 4;
e->velocity = 5;

std::cout << e->channel() << "\n";
std::cout << e->type() << "\n";
std::cout << int( e->note ) << "\n";
std::cout << int( e->velocity ) << "\n";

}

Thank you for the quick reply!

And thanks for the nice class example. I think I will go for something like
it :o)

But what is the difference between using reinterpret_cast<...> and just
doing the cast? I googled it up and read about it on MSDN, but it seems that
it is just as unsafe as the usual explicit casting.

The best,
Mogens

[Kyle]

Mogens Heller Jensen wrote:

But what is the difference between using reinterpret_cast<...> and just
doing the cast? I googled it up and read about it on MSDN, but it seems that it is just as unsafe as the usual explicit casting.

but its easier to find than C-style cast

[Gianni Mariani]

Mogens Heller Jensen wrote:
....

But what is the difference between using reinterpret_cast<...> and just
doing the cast? I googled it up and read about it on MSDN, but it seems that
it is just as unsafe as the usual explicit casting.

C style cast, i.e. "(T) x" is actually different. It overloads many
things, it also is capable of doing things that are not possible using
the C++ style casts. (C style casts can access a private base class, C++
style casts cannot.).

I use the C++ style casts now just because it's more explicit.
reinterpret casts are usually bad and so if I see alot of code that has
reinterpret casts all over it, then I will probably be looking at it
more carefully. In fact, I try to keep all my reinterpret casts in one
"type safety" class and never use reinterpret casts anywhere else.

In your case, I would probably create a "reader class" like this.

struct EventReaderWriter
{
...
Feed( const char * x ) ...

const Event * Get()
{
x += sizeof( Event );
if ( x > end ?? etc ) ...
return reinterpt_cast<const Event *>( x );
}

Event * Push()
{
...
return reinterpt_cast<Event *>( y );
}
};

It would probably look very different to this, but I think you'll get
the idea.

[Mogens Heller Jensen]

"Gianni Mariani" <gi*******@mariani.ws> wrote in message
news:-K********************@speakeasy.net...

Mogens Heller Jensen wrote:
...

But what is the difference between using reinterpret_cast<...> and just
doing the cast? I googled it up and read about it on MSDN, but it seems
that it is just as unsafe as the usual explicit casting.

C style cast, i.e. "(T) x" is actually different. It overloads many
things, it also is capable of doing things that are not possible using the
C++ style casts. (C style casts can access a private base class, C++ style
casts cannot.).

I use the C++ style casts now just because it's more explicit. reinterpret
casts are usually bad and so if I see alot of code that has reinterpret
casts all over it, then I will probably be looking at it more carefully.
In fact, I try to keep all my reinterpret casts in one "type safety" class
and never use reinterpret casts anywhere else.

In your case, I would probably create a "reader class" like this.

struct EventReaderWriter
{
...
Feed( const char * x ) ...

const Event * Get()
{
x += sizeof( Event );
if ( x > end ?? etc ) ...
return reinterpt_cast<const Event *>( x );
}

Event * Push()
{
...
return reinterpt_cast<Event *>( y );
}
};

It would probably look very different to this, but I think you'll get the
idea.

I get the idea :o)

Thanks for the input!

-Mogens