int_fast_ types and value overflow

Question

If I understand well, int_fast_n_t types are guaranteed to be at least n bits long. Depending on the compiler and the architecture of the computer these types can also be defined on more than n bits. For instance, a int_fast_8_t could be interpreted as a 32 bits int.

Is there some kind of mechanism which enforces that the value of an int_fast_n_t never overflow even if the true type is defined on more than n bits?

Consider the following code for example:

int main(){
    int_fast8_t a = 64;
    a *= 2; // -128
    return 0;
}

I do not want a to be greater than 127. If a is interpreted as a "regular" int (32 bits), is it possible that a exceed 127 and be not equal to -128?

Thanks for your answers.

Answer 1

It is absolutely possible for the result to exceed 127. int_fast8_t (and uint_fast8_t and all the rest) set an explicit minimum size for the value, but it could be larger, and the compiler will not prevent it from exceeding the stated 8 bit bounds (it behaves exactly like the larger type it represents, the "8ness" of it isn't relevant at runtime), only guarantee it can definitely represent all values in said 8 bit range.

If you need it to explicitly truncate/wrap to 8 bit values, either use (or cast to) int8_t to restrict the representable range (though overflow wouldn't be defined), or explicitly use masks to perform the same work yourself when needed.

Answer 2

int_fast8_t a = 64;
a *= 2;

If a is interpreted as a "regular" int (32 bits), is it possible that a exceed 127 and be not equal to -128?

Yes. It very likely a * 2 will save in a as 128. I would expect this on all processors unless the processor was an 8-bit one.

Is there some kind of mechanism which enforces that the value of an int_fast_n_t never overflow ?

No. Signed integer overflow is still possible as well as values outside the [-128...127] range.

I do not want a to be greater than 127

Use int8_t. The value save will never exceed 127, yet code still has implementation defined behavior in setting a 128 to an int8_t. This often results in -128 (values wrap mod 256), yet other values are possible (this is uncommon).

int8_t a = 64;
a *= 2;

---

If assignment to int8_t is not available or has unexpected implementation defined behavior, code could force the wrapping itself:

int_fast8_t a = foo();  // a takes on some value
a %= 256; 
if (a < -128) a += 256;
else if (a > 127) a -= 256;

Answer 3

Nope. All the fast types really are are typedefs. For example, stdint.h on my machine includes

/* Fast types.  */

/* Signed.  */
typedef signed char     int_fast8_t;
#if __WORDSIZE == 64
typedef long int        int_fast16_t;
typedef long int        int_fast32_t;
typedef long int        int_fast64_t;
#else
typedef int         int_fast16_t;
typedef int         int_fast32_t;
__extension__
typedef long long int       int_fast64_t;
#endif

/* Unsigned.  */
typedef unsigned char       uint_fast8_t;
#if __WORDSIZE == 64
typedef unsigned long int   uint_fast16_t;
typedef unsigned long int   uint_fast32_t;
typedef unsigned long int   uint_fast64_t;
#else
typedef unsigned int        uint_fast16_t;
typedef unsigned int        uint_fast32_t;
__extension__
typedef unsigned long long int  uint_fast64_t;
#endif

The closest you can come without a significant performance penalty is probably casting the result to an 8-bit type.

Answer 4

Just use unsigned char if you want to manipulate 8 bits (unsigned char is one byte long) you will work on 0 to 0xFF (255) unsigned range

Answer 5

From the C(99) standard:

The typedef name intN_t designates a signed integer type with width N , no padding bits, and a two’s complement representation. Thus, int8_t denotes a signed integer type with a width of exactly 8 bits.

So use int8_t to guarantee 8 bit int.

A compliant C99/C11 compiler on a POSIX platform must have int8_t.