Why bool take 1 byte?

Why bool type take 1 byte and as we know it must have only true or
false (1 or 0) that mean that it need only one bit not the a whole byte

On Oct 31, 4:54 pm, Virtual_X <C.BsM....@gmail.comwrote:Because a byte is the smallest addressible unit in the language.

Consider:

bool foo;
bool *pfoo = &foo;
If a bool consists of a single bit, now what?

Of course, you can make your own bit sets very easily if you like (to
conserve space).

user923005 wrote:I'm not sure it's a limitation in the *language* as much as it's a
hardware limitation. Basically in all existing hardware a byte is the
smallest addressable memory amount.

On Oct 31, 8:13 pm, user923005 <dcor...@connx.comwrote:use std::bitset for fixed-size bitarray and
std::vector<boolfor variable-size bitarray
however, vector<boolis pretty much a deprecated hack; if you can,
use bitset

Virtual_X wrote:You can make bool take 1 bit for example if you have a bunch of them
eg. in a struct, like this:

struct A
{
bool a:1, b:1, c:1, d:1, e:1;
};

Each one of those will only need one bit of space, and the compiler
will pack all of those bools into the same byte.

On Oct 31, 4:46 pm, Juha Nieminen <nos...@thanks.invalidwrote:thank's all

On Thu, 01 Nov 2007 02:43:52 +0200, Juha Nieminen
<nospam@thanks.invalidwrote in comp.lang.c++:
While that might be true of all the architectures that you are
familiar with, that is most certainly false in general.

There have been and still are many architectures that could read and
write individual bits.

There are still a large number of 8051 based derivatives around, even
though the original vendor no longer makes them. And the Zilog Z80
and its descendants can do the same. Although none come to mind
off-hand, I'm sure there were and are others.

The memory/register containing modifiable individual bits could also
be read or written in larger units, always 8-bit bytes, 16-bit words
in the case of the Z80, but these CPUs have single instructions that
read and write single bits, without changing the others in the unit.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

user923005 wrote:Well, I guess on a TI 34010 or 34020 you could do that. But since
sizeof(char) is defined as 1, you can't have anything smaller than a char.

Jack Klein wrote:No, the Z80 was byte addressable, though it had bit manipulation
instructions.

The TI 34010 and 34020 were true bit-addressible architectures.
However, the Standard defines sizeof(char) as 1, so the language will
not allow you to have anything smaller than a char.

On Oct 31, 9:09 pm, red floyd <no.s...@here.dudewrote:thank's again , i think bitfield is the best choice to save memory but
Is it standard or it will not work in some machines(architecture
dependent)

On 2007-11-01 13:01, Virtual_X wrote:They are standard, though there are some things about them that are
implementation-defined: allocation, alignment, and sign (i.e. in

struct A
{
int bf : 4;
};

the sign of bf is implementation dependent, so you should always add
"signed" or "unsigned" to be sure).

--
Erik Wikström

On Nov 1, 3:46 am, Juha Nieminen <nos...@thanks.invalidwrote:std::bitset is provided to obtain similar behavior.

regards,
FM.

On Nov 1, 3:41 pm, Erik Wikström <Erik-wikst...@telia.comwrote:I expected you to recomend something more standard (say std::bitset
for example)?!?!

regards,
FM.

On 2007-11-01 16:39, terminator wrote:Yes, I would recommend std::bitset, but that would not answer the
question. :-)

--
Erik Wikström

On Thu, 01 Nov 2007 05:09:05 GMT, red floyd <no.spam@here.dudewrote
in comp.lang.c++:
The fact that a Z80 actually had to read or read/modify/write an
entire 8-byte byte to test, set, or clear a single bit was completely
immaterial from an architectural point of view, that's a hardware
implementation detail.

Would you claim that a Pentium was not "really" byte addressable,
because it will read a minimum of 64 bits from memory to change the
value of just one of them?

Given:

char ca [8] = { 0 };
++ca[4];

....the processor hardware will execute at least two 64-bit bus cycles,
reading the entire contents of the array if it is suitably aligned to
get at ca[4]. If it winds up in the cache, it will eventually write
all 64 bits back to memory, even though only one 8-bit octet is
changed.

set 0,(hl)

....on a Z80 was a single, and atomic, instruction, regardless of what
the hardware did to make it happen.
True, but compilers for every bit-addressable CPU/DSP I am aware of
provide non-standard extensions to access these features.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

On Thu, 01 Nov 2007 02:46:18 +0200, Juha Nieminen wrote:However, do note that you cannot take the address of the bool
defined that way, nor pass it as a reference, i.e.
A tmp;
std::swap(A.a, A.c);
will fail at compile-time.

--
Joel Yliluoma - http://bisqwit.iki.fi/
: comprehension = 1 / (2 ^ precision)

Yannick Tremblay wrote:If you have one bool it doesn't matter. If you have one million bools,
it can matter.

On Nov 2, 1:03 pm, Joel Yliluoma <bisq...@iki.fiwrote:Obviously you mean
A tmp;
std::swap(tmp.a, tmp.c);
?

On Sat, 03 Nov 2007 01:52:56 -0000, drrngrvy wrote:Yes, sorry.

--
Joel Yliluoma - http://bisqwit.iki.fi/
: comprehension = 1 / (2 ^ precision)

On Nov 1, 7:11 pm, Erik Wikström <Erik-wikst...@telia.comwrote:oops!! I was driving too fast.

On Oct 31, 4:13 pm, user923005 <dcor...@connx.comwrote:Sorry for my bluntness. I don't think this is a good example. Because
here pfoo is a pointer to a bool, itself is not a bool. foo could be
one bit but its address can be a byte (In modern OS, the address shall
be 4 bytes or more). I think bool is not 1 bit is because the
compiler fetch data and instruction based on bytes. Even you implement
your bool as 1 bit, the whole address location will be fetched while
the code is running.

Using bitset is one way to use limited memory to do more work such as
sorting.