Efficient way to store a limited number of booleans

[mathieu]

Hi,

I was trying to make an entry in a std::map be stored more
efficiently. The struct contained 3 booleans discribing it's property,
so I am trying to make it as compact as possible.
Using a std::vector<boolin this case does not work, or at least is
not as efficient for my particular case (size was 20 bytes). Same goes
for tr1::array<bool,3>.

Is there anything else that I could have reused ?

Here is the current code:

// Compact struct to store up to 8 booleans:
struct B3
{
template <unsigned int TPos>
void SetB(bool v) {
if( v ) b.b |= (0x80 >TPos%8);
else b.b &= (~(0x80 >TPos%8));
}
template <unsigned int TPos>
bool GetB() const {
return b.b & (0x80 >(TPos%8));
}
private:
union { unsigned char b; } b;
};

Thanks
-Mathieu

[Pete Becker]

On 2007-12-11 12:13:39 -0500, mathieu <ma***************@gmail.comsaid:

>
Is there anything else that I could have reused ?

Let the compiler do the work:

struct eight_bools
{
unsigned bool0 : 1;
unsigned bool1 : 1;
unsigned bool2 : 1;
unsigned bool3 : 1;
unsigned bool4 : 1;
unsigned bool5 : 1;
unsigned bool6 : 1;
unsigned bool7 : 1;
};

eight_bools data = { 0 };
data.bool6 = true;
data.bool6 = false;

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[mathieu]

On Dec 11, 6:16 pm, Pete Becker <[e-mail]:

On 2007-12-11 12:13:39 -0500, mathieu <[e-mail]:

Is there anything else that I could have reused ?

Let the compiler do the work:

struct eight_bools
{
unsigned bool0 : 1;
unsigned bool1 : 1;
unsigned bool2 : 1;
unsigned bool3 : 1;
unsigned bool4 : 1;
unsigned bool5 : 1;
unsigned bool6 : 1;
unsigned bool7 : 1;

};

eight_bools data = { 0 };
data.bool6 = true;
data.bool6 = false;

s/unsigned/unsigned char/g

Much nicer/cleaner indeed !

Thanks
-Mathieu

[Victor Bazarov]

mathieu wrote:

On Dec 11, 6:16 pm, Pete Becker <[e-mail]:

>On 2007-12-11 12:13:39 -0500, mathieu <[e-mail]>
said:

>> Is there anything else that I could have reused ?

Let the compiler do the work:

struct eight_bools
{
unsigned bool0 : 1;
unsigned bool1 : 1;
unsigned bool2 : 1;
unsigned bool3 : 1;
unsigned bool4 : 1;
unsigned bool5 : 1;
unsigned bool6 : 1;
unsigned bool7 : 1;

};

eight_bools data = { 0 };
data.bool6 = true;
data.bool6 = false;

s/unsigned/unsigned char/g

Does it make a real difference? I mean, did you check the
'sizeof' for the resulting struct?

Much nicer/cleaner indeed !

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[mathieu]

On Dec 11, 6:32 pm, "Victor Bazarov" <[e-mail]:

mathieu wrote:

On Dec 11, 6:16 pm, Pete Becker <[e-mail]:

On 2007-12-11 12:13:39 -0500, mathieu <[e-mail]>
said:

> Is there anything else that I could have reused ?

Let the compiler do the work:

struct eight_bools
{
unsigned bool0 : 1;
unsigned bool1 : 1;
unsigned bool2 : 1;
unsigned bool3 : 1;
unsigned bool4 : 1;
unsigned bool5 : 1;
unsigned bool6 : 1;
unsigned bool7 : 1;

};

eight_bools data = { 0 };
data.bool6 = true;
data.bool6 = false;

s/unsigned/unsigned char/g

Does it make a real difference? I mean, did you check the
'sizeof' for the resulting struct?

At least on gcc 4.1.2 (debian) it does. With unsigned int I get 4
(obviously) and with unsigned char I get 1 as expected (same size as
my solution but cleaner).
-Mathieu

[mathieu]

On Dec 11, 6:32 pm, "Victor Bazarov" <[e-mail]:

mathieu wrote:

On Dec 11, 6:16 pm, Pete Becker <[e-mail]:

On 2007-12-11 12:13:39 -0500, mathieu <[e-mail]>
said:

> Is there anything else that I could have reused ?

Let the compiler do the work:

struct eight_bools
{
unsigned bool0 : 1;
unsigned bool1 : 1;
unsigned bool2 : 1;
unsigned bool3 : 1;
unsigned bool4 : 1;
unsigned bool5 : 1;
unsigned bool6 : 1;
unsigned bool7 : 1;

};

eight_bools data = { 0 };
data.bool6 = true;
data.bool6 = false;

s/unsigned/unsigned char/g

Does it make a real difference? I mean, did you check the
'sizeof' for the resulting struct?

Actually you are raising a good point. Shouldn't I be doing:
struct eight_bools
{
bool bool0 : 1;
bool bool1 : 1;
bool bool2 : 1;
bool bool3 : 1;
bool bool4 : 1;
bool bool5 : 1;
bool bool6 : 1;
bool bool7 : 1;
};

Thanks
-Mathieu

[Abhishek Padmanabh]

On Dec 11, 10:13 pm, mathieu <[e-mail]:

Hi,

I was trying to make an entry in a std::map be stored more
efficiently. The struct contained 3 booleans discribing it's property,
so I am trying to make it as compact as possible.
Using a std::vector<boolin this case does not work, or at least is
not as efficient for my particular case (size was 20 bytes). Same goes
for tr1::array<bool,3>.

Is there anything else that I could have reused ?

Here is the current code:

// Compact struct to store up to 8 booleans:
struct B3
{
template <unsigned int TPos>
void SetB(bool v) {
if( v ) b.b |= (0x80 >TPos%8);
else b.b &= (~(0x80 >TPos%8));
}
template <unsigned int TPos>
bool GetB() const {
return b.b & (0x80 >(TPos%8));
}
private:
union { unsigned char b; } b;
};

How about using std::bitset<3>?

[James Kanze]

On Dec 11, 6:16 pm, Pete Becker <[e-mail]:

On 2007-12-11 12:13:39 -0500, mathieu <[e-mail]:

Is there anything else that I could have reused ?

Let the compiler do the work:

struct eight_bools
{
unsigned bool0 : 1;
unsigned bool1 : 1;
unsigned bool2 : 1;
unsigned bool3 : 1;
unsigned bool4 : 1;
unsigned bool5 : 1;
unsigned bool6 : 1;
unsigned bool7 : 1;
};

eight_bools data = { 0 };
data.bool6 = true;
data.bool6 = false;

If he's putting this into a map, it probably won't take anymore
data space than a tr1::array< bool >, or a bool[3]. (I think he
said he only had three bools.) Whatever structure he uses will
be placed in a map node, which will also contain the key and a
couple of pointers. And be aligned and padded for pointers, at
least---on a typical machine, that means that anything less than
four bytes will in fact occupy four (or eight) bytes.

In fact, using the tr1::array<boolwill actually result in a
small space saving, because the size of the code needed to read
and write the values will be smaller.

If there's more data than just the 3 bool's, of course, bit
fields may be just the solution. Throw in a couple of ints with
very limited ranges, and the size gain can be very significant.

But of course, if he's worried about memory use, std::map may
not be the data structure he needs.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Victor Bazarov]

Abhishek Padmanabh wrote:

On Dec 11, 10:13 pm, mathieu <[e-mail]:

>Hi,

I was trying to make an entry in a std::map be stored more
efficiently. The struct contained 3 booleans discribing it's
property, so I am trying to make it as compact as possible.
Using a std::vector<boolin this case does not work, or at least
is not as efficient for my particular case (size was 20 bytes). Same
goes for tr1::array<bool,3>.

Is there anything else that I could have reused ?

Here is the current code:

// Compact struct to store up to 8 booleans:
struct B3
{
template <unsigned int TPos>
void SetB(bool v) {
if( v ) b.b |= (0x80 >TPos%8);
else b.b &= (~(0x80 >TPos%8));
}
template <unsigned int TPos>
bool GetB() const {
return b.b & (0x80 >(TPos%8));
}
private:
union { unsigned char b; } b;
};

How about using std::bitset<3>?

What is 'sizeof(std::bitset<3>)' on your machine? Just curious...

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask