Re: Why use C++?

[Paavo Helde <myfirstname@osa.pri.ee>]

"Jed" <jehdiah@orbitway.net> wrote in news:j22ddq$7pq$1@dont-email.me:

> 
> "Randy Brukardt" <randy@rrsoftware.com> wrote in message 
> news:j22c61$5lo$1@munin.nbi.dk...
> 
>> Modular types are something altogether different (and in all honesty, 
>> rare enough that direct language support is of dubious value -- most 
of 
>> us supported adding them to Ada 95 simply because it was the only way 
>> to get any support for the largest unsigned integer type).
>>
> 
> Isn't the wrapping behavior just a consequence of wanting to get a 
> representation in which signed and unsigned integers can be easily 
> converted to each other? I.e., "they" didn't sit down and say, "let's 
> implement unsigned integers with wrapping behavior". 

Indeed, the 2's complement representation allows to use the same hardware 
instruction for implementing the signed and unsigned addition (ditto for 
subtraction). However, this means that the hardware will raise the 
overflow flag exactly in the same fashion, so it would be equally easy to 
detect the overflow.

I guess that they were instead thinking about intermediate results. As 
the wrap-around point (zero) is very close to the common usage range of 
unsigned integers, it may well happen that in a complex arithmetic 
expression a temporary intermediate result may fall below zero whereas 
the final result will be OK again. This would in effect mean that the 
addition-subtraction operations would lose the associativity property, 
which would cause some headaches. E.g. the programmer should always use 
parens for indicating the relative order of addition and subtraction, 
e.g. a+(b-c) and take care that no intermediate result would overflow. As 
the common C/C++ implementations do not bother to check overflow even for 
the signed types, this would just mean that there would be a lot more of 
formally undefined behavior which seems to work as expected on a lot of 
hardware. So, instead of introducing a lot of UB they chose to make 
things like a+b-c legal by a simple trick of declaring the unsigned types 
wrap-around.

Yes, Ada could have been wiser, I'm sorry to hear this is not the case.

Cheers
Paavo