8 bit bools in packets instead of 1 bit

[Wizzard]

Why does the Packet class send 8 bits for bool data instead of 1?

Code: [Select]

Packet& Packet::operator <<(bool data)
{
    *this << static_cast<Uint8>(data);
    return *this;
}

[Nexus]

It's the same reason why bool has 8 bits and not 1. The byte is the lowest addressable unit, and sockets or streams in general work on bytes. If you inserted a single bit into a byte buffer, that would change the alignment of all the following bytes, meaning that 7 bits are in one byte and 1 in the other. This would not only make everything more complicated, but horribly inefficient. Computer architecture is conceived and optimized to work on bytes.

If you need to save space for transmission, you can do it on user side by packing multiple bits into an integer, using bitwise operators. An interesting article in this context is byte order fallacy.

[Wizzard]

I observed some open source game projects to use bit streams, and so I was inclined to ask. Thanks for the response!

Edit: Sort of curious about "horribly inefficient" (net resources more valuable usually?)

Edit: Also, I wonder if typical network compression on outgoing packets somehow fixes this

[Nexus]

What I meant is that it's usually not worth doing this kind of optimization on SFML's abstraction layer or below, because it doesn't have enough knowledge about how to efficiently pack data together. For example, re-aligning everything because of a single bool would be a very bad idea (especially because the same number of bytes is still required).

However, on the application layer, you know how to compose the data, and have more sophisticated possibilities:

• Use integers with bitwise arithmetic
• Use bitsets (std::bitset, boost::dynamic_bitset, std::vector<bool>)
• Compression algorithms like those from zlib.

[Wizzard]

Thanks again! You've helped me think a few ideas through

[Jesper Juhl]

This smells of premature optimization to me.
Why are you even worrying about little things like this? Unless a profiler told you that this is your performance bottleneck or all you are ever doing is exchanging bools, then this is likely to be of no concern what so ever in the real world.
If you are employing any kind of compression to your serialized output stream, then that's going to take care of the redundant bool bits for you easier than anything else. Even if you are not, than the rate of bools to other significant amount of data is likely to be so low that a few wasted bits are going to be lost in the noise.
Seriously, don't worry about it and don't waste your time optimizing it - in the grand scale of things it is going to be utterly irrelevant and a waste of time.