How to Detect Signed Integer Overflow in Go?

Detecting Signed Integer Overflow in Go

Integer overflow is a crucial issue to consider when working with numeric operations in any programming language, including Go. In this context, understanding how to efficiently detect integer overflow is essential to ensure data integrity and avoid unexpected behavior.

For 32-bit signed integers, Overflow can occur when the result of an arithmetic operation exceeds the maximum or minimum representable value for that type. A common misconception is that integers automatically "wrap" around when they reach their limits, but this is not the case in Go. Instead, integer overflow results in undefined behavior.

To illustrate this problem, consider the following example:

a, b := 2147483647, 2147483647
c := a + b

If we naively perform this addition, the result will not be the expected value of 4294967294, but rather 0. This is because the sum overflows the maximum value that a 32-bit signed integer can hold. Therefore, it is important to detect such overflows explicitly.

One efficient way to detect 32-bit integer overflow for addition is by checking the signs of the operands and the result. For instance, the following function performs this check for addition:

func Add32(left, right int32) (int32, error) {
    if right > 0 {
        if left > math.MaxInt32-right {
            return 0, ErrOverflow
        }
    } else {
        if left < math.MinInt32-right {
            return 0, ErrOverflow
        }
    }
    return left + right, nil
}

By implementing this type of check for each arithmetic operation, you can effectively detect and handle integer overflows in your Go code, ensuring the integrity of your computations and the robustness of your applications.

The above is the detailed content of How to Detect Signed Integer Overflow in Go?. For more information, please follow other related articles on the PHP Chinese website!