UINT_MAX + 1 equals what?

Question

What is the defined behavior in C for UINT_MAX + 1u? How safe is to assume it is zero?

@JoshPetitt: That's still zero by the way. `UINT_MAX + 1u` is evaluated as an unsigned integer, resulting in `0`, which is then stored in a `long long`. ;-) — netcoder, Feb 15 '13 at 16:49
@netcoder, on my Windows 64-bit machine you are indeed correct. My internal compiler is flawed. :-) — Josh Petitt, Feb 15 '13 at 16:58

score 28 · Accepted Answer · answered Feb 15 '13 at 16:35

28

From the standard (C11, 6.2.5/9, emphasis mine):

[...] A computation involving unsigned operands can never overflow, because a result that cannot be represented by the resulting unsigned integer type is reduced modulo the number that is one greater than the largest value that can be represented by the resulting type.

If UINT_MAX is 10:

(10 + 1) % (10 + 1) == 0

So, yes, it's safe to assume it's zero.

answered Feb 15 '13 at 16:35

netcoder

66,435
19
125
142

11

The standard mandates that `UINT_MAX` (and the maximal values of other unsigned integer types) is `2^N - 1`, where `N` is the width of the type, so 10 is a bad example (but that doesn't stop me from upvoting). – Daniel Fischer Feb 15 '13 at 16:56
Furthermore, `(unsigned) -1 == UINT_MAX`; the latter can be used in preprocessor conditions, while `(unsigned) -1` can only be evaluated by the compiler. – Loic Apr 26 '15 at 19:50

score 12 · Answer 2 · edited Jan 21 '16 at 15:29

It's worth emphasizing that while unsigned behavior is well-defined, signed integer overflow isn't:

http://en.wikipedia.org/wiki/Integer_overflow

In the C programming language, signed integer overflow causes undefined behavior, while unsigned integer overflow causes the number to be reduced modulo a power of two

A very good paper on the subject:

http://www.cs.utah.edu/~regehr/papers/overflow12.pdf

EXAMPLES OF C/C++ INTEGER OPERATIONS AND THEIR RESULTS

Expression             Result
----------             ------
UINT_MAX+1             0
LONG_MAX+1             undefined
INT_MAX+1              undefined
SHRT_MAX+1             SHRT_MAX+1 if INT_MAX>SHRT_MAX, otherwise undefined
char c = CHAR_MAX; c++ varies
-INT_MIN               undefined
(char)INT_MAX          commonly -1
1<<-1                  undefined
1<<0                   1
1<<31                  commonly INT_MIN in ANSI C and C++98; undefined in C99 and C++11
1<<32                  undefined
1/0                    undefined
INT_MIN%-1             undefined in C11, otherwise undefined in practice

score 5 · Answer 3 · 2013-02-15T18:08:39.943

5

It's safe. The C standard guarantees that unsigned integer ~~overflow~~ wrap-around results in zero.

edited Feb 15 '13 at 18:08

answered Feb 15 '13 at 16:35

2

And C strictly speaking, unsigned integers never overflow only signed integers overflow. – ouah Feb 15 '13 at 16:41
@ouah In this case, what should I say they do? – Feb 15 '13 at 16:43
1

@H2CO3: you could say they wrap around. – Steve Jessop Feb 15 '13 at 17:03

score 2 · Answer 4 · edited May 23 '17 at 12:10

2

Should be safe:

Wiki on unsigned overflow

Note the unsigned int overflow is well defined.

Also, here's a whole question on this.

edited May 23 '17 at 12:10

Community

1
1

answered Feb 15 '13 at 16:35

zw324

26,764
16
85
118

UINT_MAX + 1 equals what?

4 Answers4

Linked