Home >Backend Development >C++ >How do signed and unsigned integer overflows differ in C ?

How do signed and unsigned integer overflows differ in C ?

Barbara Streisand
Barbara StreisandOriginal
2024-11-26 08:27:10884browse

How do signed and unsigned integer overflows differ in C  ?

Integer Overflow Behavior in Signed and Unsigned Integers

Background

When working with integers in C , it's crucial to understand the behavior of integer overflow, which occurs when an integer value exceeds its maximum or minimum representable value. This article aims to explain the different outcomes of signed and unsigned integer overflow, based on the results observed in a specific program.

Program and Output

The following program was used to test integer overflow:

#include <iostream>

int main()
{
    int x(0);
    std::cout << x << std::endl;

    x = x + 2147483647;
    std::cout << x << std::endl;

    x = x + 1;
    std::cout << x << std::endl;
    std::cout << std::endl;

    unsigned int y(0);
    std::cout << y << std::endl;

    y = y + 4294967295;
    std::cout << y << std::endl;

    y = y + 1;
    std::cout << y << std::endl;
}

The program produces the following output:

0
2147483647
-2147483648

0
4294967295
0

Explanation

Signed Integer Overflow

Signed integer overflow is undefined behavior in C . This means that the result is not guaranteed and depends on the implementation. In this case, the value of x after the second increment operation wraps around to the negative minimum value of the datatype, resulting in -2147483648. This is because most implementations use the 2's complement representation for signed integers.

Unsigned Integer Overflow

Unsigned integer overflow is well-defined in C . The result is computed by modulo arithmetic, where the value wraps around to the minimum value of the datatype. In this case, the value of y after the second increment operation wraps around to 0.

Summary

In summary, signed integer overflow is undefined behavior, while unsigned integer overflow is well-defined and results in value wrapping. Therefore, it's important to handle integer overflow carefully in C programs to avoid unexpected results.

The above is the detailed content of How do signed and unsigned integer overflows differ in C ?. For more information, please follow other related articles on the PHP Chinese website!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn