Compilers and negative numbers representations

Question

Recently I was confused by this question . Maybe because I didn't read language specifications (it's my fault, I know).

C99 standard doesn't say which negative numbers representation should be used by compiler. I always thought that the only right way to store negative numbers is two's complement (in most cases).

So here's my question: do you know any present-day compiler that implements by default one's complement or sign-magnitude representation? Can we change default representation with some compiler flag?

What is the simplest way to determine which representation is used?

And what about C++ standard?

Answer 1

I think it's not so much a question of what representation the compiler uses, but rather what representation the underlying machine uses. The compiler would be very stupid to pick a representation not supported by the target machine, since that would introduce loads of overhead for no benefit.

Some checksum fields in the IP protocol suite use one's complement, so perhaps dedicated "network accelerator"-type CPU:s implement it.

Answer 2

The UNISYS 2200 series which implements one's complement math, is still in use with some quite updated compiler. You can read more about it in the questions below

• Exotic architectures the standards committees care about
• Are there any non-twos-complement implementations of C?

Answer 3

While twos-complement representation is by far the most common, it is not the only one ( see some ). The C and C++ standardisation committees did not want to require non-twos-complement machines to emulate a non-native representation. Therefore neither C not C++ require a specific negative integer format.

This leads to the undefined behaviour of bitwise operations on signed types.