Re: char data to unsigned char
On May 2, 2:54 am, "Alf P. Steinbach" <al...@start.no> wrote:
On 02.05.2010 03:43, * Jonathan Lee:
[...]
What's the proper way to process char data as unsigned char?
A lot of the things I write are only defined on "raw" data.
Like, huffman decoding, or block ciphers. But a lot of this
data comes from files or strings which are char sources. The
way I've been handling this until now is to simply
reinterpret_cast<> a pointer to a char buffer into an
unsigned char pointer. Like
// convenience
void encrypt(const char* data, std::size_t n) {
encrypt(reinterpet_cast<const unsigned char*>(data, n);
}
// "real" function
void encrypt(const unsigned char* data, std::size_t n) {
..
}
I don't see any guarantee in the standard that this will work, and
it's bugging me.
Don't let it. There's no formal guarantee about assigning back
to char, but (1) you're probably not doing any assigning back
to plain char, and (2) that lack of formal guarantee is just
in support of sign-and-magnitude char's on the ENIAC (some
member of the C++ committee fancies the ENIAC). Nobody uses
the ENIAC any more, and besides, there's no C++ compiler for
that machine.
First, I don't know whether the ENIAC used signed magnitude, but
there are machines being sold today (so presumably also used)
which use signed magnitude or one's complement. The one with
one's complement definitely has a C++ compiler. Not everything
is a PC. (Of course, absolute portability isn't a requirement
for all applications, and if you're using, say, WinMain instead
of main, you can pretty ignore the existance of "unusual"
architectures.)
Which doesn't mean your basic premise is wrong. The C++
standard is a little vague about this, but I'd argue that the
intent is that copying any POD type as a char (e.g. through a
char*) is value preserving, regardless of the original type.
(IIRC, this is not the case for C, which only guarantees value
preservation in the case of unsigned char. But I could be wrong
about this.) And of course, this is trivial to guarantee on any
machine which meets the guarantees for unsigned char---just make
plain char unsigned. (This is what Univac does for both the
2200 and the MCP architectures---one's complement and signed
magnitude, respectively.)
Independently of the standard... One of the most common idioms
in C is something like:
char* p;
int c = getchar();
while (c != EOF && c != '\n')
*p ++ = c;
This only works if you are able to assign an int with the values
0...UCHAR_MAX to a char without loss of information. Something
which is explicitly *not* guaranteed by the standard. But
something which is so ubiquous that no one would dare violate
it. (And as I said above, it is guaranteed that you can
implement it, relatively cheaply, in fact, by making plain char
unsigned.)
--
James Kanze