Re: Serializing bit field structures
On Oct 21, 11:18 am, "(2b|!2b)==?" <void-s...@ursa-major.com> wrote:
I have a struct declared as follows:
struct RecordType1
{
unsigned int dt : 24; //3 bytes
unsigned int ts : 16; //2 bytes
unsigned int lsp : 24; //3 bytes (float value represente=
d as int)
unsigned int lst : 16; //2 bytes
unsigned int lsv : 16; //2 bytes
unsigned int x1 : 24; //3 bytes (float value represente=
d as int)
unsigned int x2 : 24; //3 bytes (float value represente=
d as int)
unsigned int x3 : 24; //3 bytes (float value represente=
d as int)
unsigned int x4 : 24; //3 bytes (float value represente=
d as int)
unsigned int bv : 16; //2 bytes
unsigned int ak : 24; //3 bytes (float value represente=
d as int)
unsigned int av : 16; //2 bytes
unsigned int cv : 24; //3 bytes
};
Note that on a 32 bit machine, the only effect your bit fields
are likely to have here is to slow things down, since generally,
the compiler won't allocate a bit field in a way that would
cross a 32 bit boundary. lst and lsv will be put into a single
word, but that's about it, and you could get that by declaring
them as unsigned short. If you're really concerned about memory
use, you probably need to declare each field to be an array of
unsigned char of the correct size, and use memcpy for copying in
and out. Otherwise, just drop the bit fields---they don't buy
you anything. (Here---if you had 8 or ten in a row, of just a few
bits, they could make a difference. But there's rarely any
sense in having bit fields larger than 8 bits.)
I need to serialize this struct by packing the bits into a
contiguous byte array, and then read it back from the byte
array. I cant use memcpy/sizeof because of boundary alignment
...
I'd appreciate if anyone can show me how to do this. Ieally, I
would like to this in a cross platform (i.e. "ENDIAN-ness"
agnostic) way.
The first thing you'll have to do is define the format you want
for the serialized data. Once you've done that, you need to
process each field separately. If we assume that you have 16
bit unsigned integral values, and 24 bit custom floating point,
kept internally in an unsigned int, and that you decide to use
the standard network byte order (for unsigned values, byte order
is the only concern, and you've alread specified a floating
point format which maps it to an unsigned value), then something
like:
void
putIntValue( std::ostream& dest, unsigned value )
{
dest << ((value >> 8) & 0xFF)
<< ((value ) & 0xFF) ;
}
void
putFloatValue( std::ostream& dest, unsigned value )
{
dest << ((value >> 16) & 0xFF)
<< ((value >> 8) & 0xFF)
<< ((value ) & 0xFF) ;
}
would do the trick; even cleaner would be to define your own
stream types for this (inheriting from std::ios, but not from
std::istream or std::ostream), with << and >> operators for the
basic types your concerned with (with the conversions between
float and your representation also taking place in the << and >>
operator).
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34