极客笔记如何在C++中避免整数溢出和下溢？
在 C++ 中，整数类型是一种常用的数据类型。但是，整数类型只能表示有限的数值范围，当数值超出该范围时，就会出现整数溢出和下溢的情况。本文将介绍如何在 C++ 中避免整数溢出和下溢。
什么是整数溢出和下溢？
在 C++ 中，整数类型可以分为带符号整数和无符号整数两种类型。带符号整数类型可以表示正数、负数和 0，其中最高位为符号位。无符号整数类型只能表示非负数，即 0 和正整数。
当带符号整数类型的值超出其表达范围时，会发生整数溢出。其中，超出正数的部分会变成负数，超出负数的部分会变成正数。
例如，在 32 位带符号整数类型 int 中，最小值为 -2^31，最大值为 2^31-1。如果我们定义一个变量 a 等于最大值，再将其加上 1，则 a 的值会变成最小值 -2^31：
#include <iostream>
int main() {
int a = 2147483647; // 最大值
std::cout << a << std::endl; // 输出 2147483647
a = a + 1; // 溢出
std::cout << a << std::endl; // 输出 -2147483648
return 0;
}
如果我们定义一个变量 b 等于最小值 -2^31，再将其减去 1，则 b 的值会变成最大值 2^31-1：
#include <iostream>
int main() {
int b = -2147483648; // 最小值
std::cout << b << std::endl; // 输出 -2147483648
b = b - 1; // 下溢
std::cout << b << std::endl; // 输出 2147483647
return 0;
}
当无符号整数类型的值超出其表达范围时，会发生模运算。其中，超出最大值的部分会被模成 0，超出最小值的部分会被模成最大值加 1。
例如，在 32 位无符号整数类型 unsigned int 中，最大值为 2^32-1。如果我们定义一个变量 c 等于最大值，再将其加上 1，则 c 的值会变成 0：
#include <iostream>
int main() {
unsigned int c = 4294967295; // 最大值
std::cout << c << std::endl; // 输出 4294967295
c = c + 1; // 模运算
std::cout << c << std::endl; // 输出 0
return 0;
}
如果我们定义一个变量 d 等于 0，再将其减去 1，则 d 的值会变成最大值 2^32-1：
#include <iostream>
int main() {
unsigned int d = 0; // 最小值
std::cout << d << std::endl; // 输出 0
d = d - 1; // 模运算
std::cout << d << std::endl; // 输出 4294967295
return 0;
}
综上，整数溢出和下溢可能会导致程序出错，因此需要避免其发生。
如何避免整数溢出和下溢？
在 C++ 中，有许多方法可以避免整数溢出和下溢。下面介绍其中的几种方法。
使用较大的整数类型
我们可以使用较大的整数类型来存储整数类型，例如使用 long long 来代替 int。这样可以使得存储的数值范围更大，从而避免溢出和下溢的情况。
例如，我们可以定义一个变量 a 等于最大值 2^31-1，再将其加上 1。如果使用 long long 类型，则不会发生溢出：
#include <iostream>
int main() {
long long a = 2147483647; // 最大值
std::cout << a << std::endl; // 输出 2147483647
a = a + 1; // 不会溢出
std::cout << a << std::endl; // 输出 2147483648
return 0;
}
使用无符号整数类型
使用无符号整数类型可以避免带符号整数溢出和下溢的情况。因为无符号整数类型只能表示非负数，所以不存在负数部分溢出为正数或正数部分溢出为负数的情况。不过，无符号整数类型仍然存在模运算的情况。
例如，我们可以定义一个变量 c 等于最大值 2^32-1，再将其加上 1。如果使用 unsigned int 类型，则不会溢出，而是发生模运算：
#include <iostream>
int main() {
unsigned int c = 4294967295; // 最大值
std::cout << c << std::endl; // 输出 4294967295
c = c + 1; // 模运算
std::cout << c << std::endl; // 输出 0
return 0;
}
使用适当的数据类型
在许多情况下，我们并不需要使用整数类型的完整数值范围，因此可以选择适当的数据类型来表示。例如，如果只需要表示 0 到 100 的整数，则可以使用 unsigned char 类型，其它数据类型则会浪费空间（int 类型需要 4 个字节，而 unsigned char 类型只需要 1 个字节）。
例如，我们可以定义一个变量 d 等于最大值 100，再将其加上 1。如果使用 unsigned char 类型，则不会发生溢出，但会发生模运算：
#include <iostream>
int main() {
unsigned char d = 100; // 最大值
std::cout << (int)d << std::endl; // 输出 100
d = d + 1; // 模运算
std::cout << (int)d << std::endl; // 输出 101
return 0;
}
使用异常处理机制
如果整数溢出和下溢发生在异常情况下，可以使用异常处理机制来在程序运行时捕捉和处理异常。
例如，我们可以定义一个函数 divide，它接受两个整数作为参数，返回它们的商。如果除数为 0，则抛出一个异常：
#include <iostream>
double divide(int dividend, int divisor) {
if (divisor == 0) {
throw "Division by zero!";
}
return (double)dividend / divisor;
}
int main() {
try {
double result = divide(5, 0);
std::cout << result << std::endl;
} catch (const char* message) {
std::cerr << "Error: " << message << std::endl;
}
return 0;
}
在上面的代码中，我们定义了一个异常处理块，用 try 和 catch 关键字包围起来。如果 divide 函数抛出一个异常，则程序会跳转到 catch 块中处理该异常。
结论
在 C++ 中，避免整数溢出和下溢是一项重要的任务。我们可以使用较大的整数类型、无符号整数类型、适当的数据类型和异常处理机制来避免整数溢出和下溢的情况。在编写程序时，我们应该特别注意整数类型的范围，并选择适当的数据类型来表示整数。如果在程序执行过程中出现异常，我们应该使用异常处理机制来捕捉和处理异常，从而避免程序出错。