Re: The right way to handle this difference in Ada

[Marius Amado Alves <amado.alves@netcabo.pt>]

Steve wrote:

> When programming in C/C++ you think in terms of the small fixed set of data
> types that map to the hardware...
> 
> C/C++ thinking:
>   Let's see... I have a value that is going to be in the range of 0 to 457.
> That means I'll need to use a 16 bit value.  I'll use a short or an unsigned
> short, since I know that on the machine I am programming, short values are
> 16 bit.
> 
> Ada thinking:
>   Let's see... I have a value that is going to be in the range of 0 to 457.
> I'll define a tyhpe and let the compiler worry about it.
> 
>   type My_Type is range 0 .. 457;
> 
>   The only time you really need to worry about the number of bits is when
> you are programming interfaces.

This is wise advice up until here. Original Poster, follow it. Welcome 
to the Ada Way.

>   Back to your question.  Your question leads to another question: what
> should happen if I subtract two variables of type unsigned_int_12_type?

No. You should ask: why do I want to subtract? What is the resulting 
type? An intermediary value in an expression? A definitive value? Of 
what type?

>   If you want the values to "wrap" like unsigned values in C++, you should
> define your type using a "mod" type instead.  If the result of your
> subraction is always going to be a signed value in the range of
> unsigned_int_12_type, then go ahead and define c as an unsigned_int_12_type.
> If the difference is out of range, you'll get a runtime error.
> 
>  Since you indicated your background is C++, I'm guessing you want the type
> to behave more like an unsigned value in C++ and ignore out of range
> conditions.  If that is the case, change your definition to:
> 
>   type unsigned_int_12_type is mod 2**12;
> 
>   And define c of the same type...

For some reason in this part of the reply Steve has regressed to what he 
himself calls "C/C++ thinking". Original Poster, ignore.