How Do I Detect Unsigned Integer Overflow in C++?

In C++, unsigned integer is a datatype that can store only zero and non-negative integer values. According to C++ standard, unsigned integer overflow is defined behavior (as it wraps around using modulo arithmetic and starts again from 0). So, to detect when this wrapping occurred is important to detect the overflow. In this article, we will learn how to detect unsigned integer overflow in C++.

Detecting Unsigned Integer Overflow in C++

The most simple and efficient method to detect the unsigned integer overflow is to check for overflow before performing an arithmetic operation. This involves comparing the operands against the maximum value that the type can hold before performing the operation.

Approach

• Obtain the maximum value that an unsigned integer can hold using numeric_limits<unsigned int>:: max() function.
• Check for Addition Overflow:
  • Before performing the addition, check if the second operand (b) is greater than the maximum value minus the first operand (a). If true, then adding a and b will definitely overflow.
    
• Check for Multiplication Overflow:
  • Before multiplying, check if the first operand (a) is greater than the maximum value divided by the second operand (b) (given b is not zero). If true, a * b will overflow.
    
• If no overflow is detected using the pre-checks, perform the operations normally and print the result.

Note: When an overflow occurs, the value of the unsigned integer is reset to zero and the higher bits are lost.

C++ Program to Detect Unsigned Integer Overflow

The following program illustrates how we can detect unsigned integer overflow in C++.

// C++ Program to Detect Unsigned Interger Overflow

#include <iostream>
#include <limits>
using namespace std;

// Function to check if addition will overflow
bool willAdditionOverflow(unsigned int a, unsigned int b)
{
    return b > numeric_limits<unsigned int>::max() - a;
}

// Function to check if multiplication will overflow
bool willMultiplicationOverflow(unsigned int a,
                                unsigned int b)
{
    if (a == 0 || b == 0) {
        return false; // Multiplication with zero never
                      // overflows
    }
    return a > numeric_limits<unsigned int>::max() / b;
}

int main()
{
    unsigned int a = numeric_limits<unsigned int>::max();
    unsigned int b = 1;

    // Check for addition overflow
    if (willAdditionOverflow(a, b)) {
        cout << "Addition overflow will occur!" << endl;
    }
    else {
        unsigned int result = a + b;
        cout << "Result of addition: " << result << endl;
    }

    unsigned int c = numeric_limits<unsigned int>::max();
    unsigned int d = 2;

    // Check for multiplication overflow
    if (willMultiplicationOverflow(c, d)) {
        cout << "Multiplication overflow will occur!"
             << endl;
    }
    else {
        unsigned int result = c * d;
        cout << "Result of multiplication: " << result
             << endl;
    }

    return 0;
}

Addition overflow will occur!
Multiplication overflow will occur!

Time Complexity: O(1)
Auxiliary Space: O(1)