Re: do { quit; } else { }

On 14.04.2025 15:00, James Kuyper wrote:

On 4/14/25 00:43, Janis Papanagnou wrote:
...

Honestly, this is an old, known argument that I could never fully
understand. 'char' for characters, 'int' as a register sized entity,
'short' and 'long' as, say, additions. So far so good. "For a wide
variety of platforms" you cannot just use 'int' and hope that works
on 8, 16, or 32 bit processors the same way. Switching to 'long' or
'short' also doesn't provide any portability property since you've
no guarantee whether the necessary ranges can be represented with
them.

 
Huh? There's guarantees for every one of those types.

Has that changed? - I recall that there were only "compare to"
relations defined, like               |short| <= |int| <= |long|

and there where systems where it was  |short| == |int| == |long|
and other systems with                |short| <  |int| == |long|
or    |short| < |int| < |long|   or   |short| == |int| <  |long|

 
Obviously, when interfacing with other software, I need to use the types
used in that interface. and that is the only context in which I would
use one of the exact-sized types.

Yes.

Whenever I'm free to choose the type
of an integer variable, I normally prefer the fast size-named types,
unless storage space is an issue, in which case I use the least
size-named types.

Yes.

The guarantees associated with the older types make
them roughly equivalent to the following size-named types:
 
[un]signed char     [u]int_least8_t
[unsigned]short     [u]int_least16_t
[unsigned]int       [u]int_fast16_t
[unsigned]long      [u]int_least32_t
[unsigned]long long [u]int_least64_t

And that is where I have a different experience. - AFAICT, these
size equivalences were not a given.

 
Even before the size-named types came out, I always programmed with
those types as if they were the corresponding size-named types listed
above. Those types weren't ideal - too few of them can be described as
corresponding to one of the fast size-named types. However, they were
portable if used with due consideration of what guarantees went with
each type.

Was your programming focused to systems where the sizes were (by
accident) equal?

Janis