Hi PRC,
In C++ (and C too), it is really best to think of char as non-signed.
If you need to manipulate bytes of data, take a page from the Java
programming manual and do this:
typedef char byte;
byte b = GetByte();
if ((b & 0xFF) < 200)
{
std::cout << "byte is under 200" << std::endl;
}
The explicit (b & 0xFF) converts the byte to an int, and ensures that it is
between 0 and 255.
Also, the explicit (b & 0xFF) tells any other programmer that follows in
your footsteps that the value is ensured to be between 0 and 255.
It's safe from char being signed or unsigned, which is not reliable from
platform to platform.
Also, using 'byte' instead of 'char' is a way to convey, in code (rather
than in comment) that you are working with byte information and not
character information.
(The above assumes that the size of a byte is an octet. If you are on a
platform that has a byte of a different bit-size, you may need to
accommodate accordingly.)
And on my platforms, (b & 0xFF) optimizes very well. Apparently most CPUs
are pretty good at bit twiddling. :-)
Some may advocate using 'unsigned char' for byte. I used to advocate that,
too (via: typedef unsigned char byte;). After a stint doing Java
development, I've changed my mind and now much prefer using an unspecified
'char' for byte (via: typedef char byte;), and employ the (b & 0xFF)
paradigm when/where needed. More typing, but -- in my opinion -- much
better code clarity, better self-documenting code, and less obfuscation.
In the end, it's a matter of coding style and personal preference. The
above is my recommendation, for you consideration.
HTH,
--Eljay
