bit on bool

[bark]

Given

class F
{
public:
bool a:1;
};

is there any point writing like this? I am refering to the "bool a:1;"

tia
Anders.

[bark]

On Aug 13, 10:00*am, bark <[e-mail]:

Given

class F
{
public:
bool a:1;

};

is there any point writing like this? I am refering to the "bool a:1;"

tia
Anders.

humm.. after rereading my post maybe I should add some more
clarification:

in the original class where I found this it looks like

class F
{
<<...>>
bool a:1;
bool b:1;
bool c:1;
bool d:1;

<<some other declarations not bools and not using bitspec.>>
};

now I presume the author wanted to save some space - even though I
find it a bit pointless since it is not used in an application where
memory is critical but ok, I hadn't seen this way to write bool's
before.

So I was wondering what your take is on this? Is there some kind of
other benefit that I don't know about?

TIA
Anders again

[ajk]

On Aug 13, 11:16*am, "Alf P. Steinbach" <[e-mail]:

* bark:

On Aug 13, 10:00 am, bark <[e-mail]:

Given

class F
{
public:
bool a:1;

};

is there any point writing like this? I am refering to the "bool a:1;"

tia
Anders.

humm.. after rereading my post maybe I should add some more
clarification:

in the original class where I found this it looks like

class F
{
<<...>>
* *bool a:1;
* *bool b:1;
* *bool c:1;
* *bool d:1;

<<some other declarations not bools and not using bitspec.>>
};

now I presume the author wanted to save some space - even though I
find it a bit pointless since it is not used in an application where
memory is critical but ok, I hadn't seen this way to write bool's
before.

So I was wondering what your take is on this? Is there some kind of
other benefit that I don't know about?

Might be efficiency, if these F's are passed around by value in zillions of
calls, or memory consumption if a quadzillion of them are in an array, or
matching layout of some lower level API or hardware.

Otherwise it just wastes both programmer and program time.

Difficult to say without more context info.

Cheers, & hth.,

- Alf

Thanks Alf,

the context is a compiler, so normally this would mean a one time
buildup of an abstract syntax tree where each tree node has 4 of these
bool's. I think we are talking about max a few thousand nodes so all
in all it seems useless.

br/Anders.

[James Kanze]

On Aug 13, 6:05 am, ajk <[e-mail]:

On Aug 13, 11:16 am, "Alf P. Steinbach" <[e-mail]:

[...]

in the original class where I found this it looks like

class F
{
<<...>>
bool a:1;
bool b:1;
bool c:1;
bool d:1;

<<some other declarations not bools and not using bitspec.>>
};

Might be efficiency, if these F's are passed around by value
in zillions of calls, or memory consumption if a quadzillion
of them are in an array, or matching layout of some lower
level API or hardware.

Otherwise it just wastes both programmer and program time.

Difficult to say without more context info.

the context is a compiler, so normally this would mean a one
time buildup of an abstract syntax tree where each tree node
has 4 of these bool's. I think we are talking about max a few
thousand nodes so all in all it seems useless.

(More likely a few tens of thousands of nodes, or even hundreds
of thousands. But still a lot less that the zillions Alf
mentioned.)

It's probably a waste of time today. It might have been less
useless back in the days of 16 bit machines, and might be a
holdover from then. (While it wastes programmer time to write
it when you don't need it, if you already have it, it's probably
not worth the programmer time to change it.) Or just a
programmer who got into the habit back then, and hasn't evolved.
Conceivably, if there's a special allocator for F, which ensures
locality, it might reduce cache misses and page faults some, but
I'd be fairly surprised if it made a noticeable difference.

--
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]