In computer programming, an integer overflow occurs when an arithmetic operation attempts to create a numeric value that is larger than can be represented within the available storage space. For instance, adding 1 to the largest value that can be represented constitutes an integer overflow. The most common result in these cases is for the least significant representable bits of the result to be stored (the result is said to wrap). On some processors like GPUs and DSPs, the result saturates, that is once the maximum value is reached attempts to make it larger simply return the maximum result.
Contents 
The register width of a processor determines the range of values that can be represented. Typical binary register widths include:
Since an arithmetic operation may produce a result larger than the maximum representable value, a potential error condition may result. 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, meaning that unsigned integers "wrap around" on overflow.
A "wrap around" corresponds to the fact, that e.g. if the addition two positive integers produces an overflow, it may result in a negative number. In counting, one just starts over again from the bottom. Example: 16 bit signed integer: 30000 + 30000 = 5536.
In computer graphics or signal processing, it is typical to work on data that ranges from 0 to 1 or from 1 to 1. An example of this is a grayscale image where 0 represents black, 1 represents white, and values inbetween represent varying shades of gray. One operation that one may want to support is brightening the image by multiplying every pixel by a constant. Saturated arithmetic allows one to just blindly multiply every pixel by that constant without worrying about overflow by just sticking to a reasonable outcome that all these pixels larger than 1 (i.e. "brighter than white") just become white and all values "darker than black" just become black.
In some situations a program may make the assumption that a variable always contains a positive value. If the variable has a signed integer type an overflow can cause its value to wrap and become negative, violating the assumption contained in the program and perhaps leading to unintended behavior. Similarly, subtracting from a small unsigned value may cause it to wrap to a large positive value which may also be an unexpected behavior. Multiplying or adding two integers may result in a value that is nonnegative, but unexpectedly small. If this number is used as the number of bytes to allocate for a buffer, the buffer will be allocated unexpectedly small, leading to a potential buffer overflow.
Some languages, such as Lisp and Ada, provide mechanisms that, if used, result in accidental overflow triggering an exception condition. Many languages do not support such functionality. In Python, a number that becomes too large for an integer seamlessly becomes a long.^{[1]} And in Python 3.0, integers and arbitrary sized longs are unified.^{[2]}
List of techniques and methods that might be used to mitigate against the consequences of integer overflow:
