When to address integer overflow in C

Question

Related question: How to detect integer overflow?

In C code, should integer overflow be addressed whenever integers are added? It seems like pointers and array indexes should be checked at all. When should integer overflow be checked for?

When numbers are added in C without type explicitly mentioned, or printed with printf, when will overflow occur?

Is there a way to automatically detect integer arithmetic overflow?

When? Whenever you need to, of course. If integer overflow is a possibility *and* it would lead to bad results, you should check for it. A example of a bad result is an airplane crashing, or a nuclear reaction running out of control. — President James K. Polk, Apr 25 '10 at 19:09
Agree with GregS. Also see https://www.securecoding.cert.org/confluence/display/seccode/CERT+C+Secure+Coding+Standard — L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳, Apr 25 '10 at 19:12
I don't think I'd want to use C for airplanes or nuclear reactors in the first place... — Ken, May 01 '10 at 23:51

score 2 · Accepted Answer · answered Apr 25 '10 at 19:09

I've heard about setjmp()- or longjmp()-based exception handling in C, but I think there's no native way of doing this. What I usually do is just make sure the types used are long enough to contain all the additions/multiplications I'll need to make.

The whole point of using C, as opposed to managed languages such as C#, which will throw an OverflowException, is precisely the fact that no CPU power is wasted on safety checks. C will simply turn the counter around, and go from FFFFFFFF to 00000000, so you can check for that (if a>b and such), but other than that I can just recommend using longer types. 64 bits (long long) should address all your needs.

Overflow won't occur when you print a number with printf, or at least I haven't heard of such a possibility. For additions, I'd just use adequate types and tell the compiler how to interpret the values so that you can avoid unnecessary casts (like, the literal "123" will be interpreted as 32 bit, but "123LL" will be 64 bit - same as with ".1f" vs. ".1").

For array indices - you should always make sure you don't read/write out of your array, as C in many cases will happily corrupt your data without causing an error.

As for when integer overflow should be checked for... Well, whenever it may occur and you don't want it to occur :).

I had played with setjmp/longjmp exception handling in C. to add to this answer, check my profile for a question I asked about it with a working example of handling the floating point exception via setjmp/longjmp. — , May 01 '10 at 23:38

score 2 · Answer 2 · answered Apr 25 '10 at 19:38

The general answer is rarely. If the result should be valid, but overflowed instead then you should have used a larger type. If the largest type isn't sufficient then you should have used a big int library.

There is no automatic, standard way to detect this built into C. Some hardware supports it, but it isn't standard. This was covered in the thread you linked to.

The type of literals is always defined, it's just not always explicit. Here's a list of literal types. Generally performing arithmetic with literals will overflow either if you manage to overflow whatever type the compiler uses for intermediate operation, or when the result gets assigned to a type of lower precision that doesn't have enough space.

score 2 · Answer 3 · answered May 01 '10 at 23:42

When you say "automatically detect overflow", what exactly do you mean? Overflow detection as a debugging tool, i.e. something that aborts our program is a way similar to a failed assertion? Or some kind of full-time run-time mechanism that would let you detect and handle the situation gracefully?

If you are interested in it as a debugging tool, then you should consult your compiler documentation. GCC, for example, provides -ftrapv option that "generates traps for signed overflow on addition, subtraction, multiplication operations" (see code generation options)

When to address integer overflow in C

3 Answers3