学习 C++ / 第 6.3 课

取余与幂运算

13 分钟阅读

取余运算符(operator%)

取余运算符(也常称为模运算符或模数运算符)会返回整数除法后的余数。 例如, 7 / 4 = 1,余数为 3,因此 7 % 4 = 3。再例如,25 / 7 = 3,余数为 4,因此 25 % 7 = 4。 取余运算符只能用于整数操作数。

它最常用于判断一个数能否被另一个数整除(即除法后没有余数):如果 x % y 求值为 0,就知道 x 可以被整除。 y.

C++
#include <iostream>

int main()
{
	std::cout << "请输入整数:";
	int x{};
	std::cin >> x;

	std::cout << "Enter another integer: ";
	int y{};
	std::cin >> y;

	std::cout << "余数为: " << x % y << '\n';

	if ((x % y) == 0)
		std::cout << x << " 可以被整除。 " << y << '\n';
	else
		std::cout << x << " is not evenly divisible by " << y << '\n';

	return 0;
}

下面是该程序的几次运行结果:

请输入整数:6
Enter another integer: 3
余数为: 0
6 可以被整除。 3
请输入整数:6
Enter another integer: 4
余数为: 2
6 is not evenly divisible by 4

现在看第二个数大于第一个数的例子:

请输入整数:2
Enter another integer: 4
余数为: 2
2 is not evenly divisible by 4

余数为 2 乍看可能不太直观,但其实很简单:2 / 4 使用整数除法得到 0,余数为 2。当第二个数大于第一个数时,第二个数会将第一个数除 0 次,因此第一个数就是余数。

负数取余

取余运算符也可以处理负操作数。x % y 的结果始终与 x 的符号相同。

运行上面的程序:

请输入整数:-6
Enter another integer: 4
余数为: -2
-6 is not evenly divisible by 4
请输入整数:6
Enter another integer: -4
余数为: 2
6 is not evenly divisible by -4

两种情况下都可以看到,余数的符号与第一个操作数相同。

术语

C++ 标准实际上没有为 operator% 单独规定名称。不过,C++20 标准指出:“二元 % 运算符产生第一个表达式除以第二个表达式的余数”。

虽然 operator% 常被称为“模运算符”或“模数运算符”,但这容易造成混淆,因为数学中的模运算通常按另一种方式定义;当 C++ 中恰好一个操作数为负数时,两者可能得到不同结果。

例如在数学中:
-21 modulo 4 = 3
-21 remainder 4 = -1

因此我们认为,“余数”比“模”更准确地描述 operator% ,而不是“模”。

当第一个操作数可能为负时,要注意余数也可能为负。例如,你可能会这样编写判断数字是否为奇数的函数:

C++
bool isOdd(int x)
{
    return (x % 2) == 1; // 当 x 为 -5 时失败
}

但是,当 x 是负奇数(例如 -5)时,这种写法会失败,因为 -5 % 2 的结果是 -1,而 -1 不等于 1。

因此,如果要比较取余运算的结果,最好与 0 比较,这样不会遇到正负号问题:

C++
bool isOdd(int x)
{
    return (x % 2) != 0; // 也可以写成 return (x % 2)
}

最佳实践

最佳实践:如果可能,比较取余运算符(operator%)的结果时请与 0 比较。

幂运算符在哪里?

请注意,^ 运算符(数学中常用来表示幂运算)在 C++ 中是按位异或运算(详见课程 O.3 —— 使用按位运算符和位掩码进行位操作)。C++ 没有幂运算符。

要在 C++ 中进行幂运算,请包含 <cmath> 头文件并使用 pow() 函数:

C++
#include <cmath>

double x{ std::pow(3.0, 4.0) }; // 3 的 4 次方

请注意,pow() 函数的参数和返回值类型都是 double。由于浮点数存在舍入误差,pow() 的结果可能不精确(即使传入整数或整值)。

如果要进行整数幂运算,最好自己编写函数。下面的函数实现了整数幂运算(为提高效率使用了“平方求幂”算法):

C++
#include <cassert> // 用于 assert
#include <cstdint> // 用于 std::int64_t
#include <iostream>

// 注意:exp 必须为非负数
// 注意:不检查范围或溢出,请谨慎使用
constexpr std::int64_t powint(std::int64_t base, int exp)
{
	assert(exp >= 0 && "powint: exp parameter has negative value");

	// 处理 0 的情况
	if (base == 0)
		return (exp == 0) ? 1 : 0;

	std::int64_t result{ 1 };
	while (exp > 0)
	{
		if (exp & 1)  // 如果 exp 为奇数
			result *= base;
		exp /= 2;
		base *= base;
	}

	return result;
}

int main()
{
	std::cout << powint(7, 12) << '\n'; // 7 的 12 次方

	return 0;
}

输出:

13841287201

如果不理解该函数的工作方式也不用担心——调用它并不要求理解内部实现。

相关内容

断言见课程 9.6 —— assert 与 static_assert,constexpr 函数见课程 F.1 —— constexpr 函数。

进阶读者

如果在常量表达式中使用,constexpr 说明符允许函数在编译期求值;否则它像普通函数一样在运行时求值。

警告

绝大多数情况下,整数幂运算都会导致整数类型溢出。 这可能就是标准库一开始没有提供这类函数的原因。

下面是会检查溢出的更安全版本:

C++
#include <cassert> // 用于 assert
#include <cstdint> // 用于 std::int64_t
#include <iostream>
#include <limits> // 用于 std::numeric_limits

// 更安全但更慢的 powint() 版本,会检查溢出
// 注意:exp 必须为非负数
// 发生溢出时返回 std::numeric_limits<std::int64_t>::max()
constexpr std::int64_t powint_safe(std::int64_t base, int exp)
{
    assert(exp >= 0 && "powint_safe: exp parameter has negative value");

    // 处理 0 的情况
    if (base == 0)
        return (exp == 0) ? 1 : 0;

    std::int64_t result { 1 };

    // 为简化范围检查,确保 base 为正数
    // 如有需要,最后再对结果取反
    bool negativeResult{ false };

    if (base < 0)
    {
        base = -base;
        negativeResult = (exp & 1);
    }

    while (exp > 0)
    {
        if (exp & 1) // 如果 exp 为奇数
        {
            // 检查结果乘以 base 是否会溢出
            if (result > std::numeric_limits<std::int64_t>::max() / base)
            {
                std::cerr << "powint_safe(): result overflowed\n";
                return std::numeric_limits<std::int64_t>::max();
            }

            result *= base;
        }

        exp /= 2;

        // 如果完成了,就在此处退出
        if (exp <= 0)
            break;

        // 只有还要继续迭代时才需要执行以下代码

        // 检查 base 与自身相乘是否会溢出
        if (base > std::numeric_limits<std::int64_t>::max() / base)
        {
            std::cerr << "powint_safe(): base overflowed\n";
            return std::numeric_limits<std::int64_t>::max();
        }

        base *= base;
    }

    if (negativeResult)
        return -result;

    return result;
}

int main()
{
	std::cout << powint_safe(7, 12) << '\n'; // 7 的 12 次方
	std::cout << powint_safe(70, 12) << '\n'; // 70 的 12 次方(会返回 64 位整数的最大值)

	return 0;
}

测验时间

问题 #1

下面的表达式求值结果是什么? 6 + 5 * 4 % 3

显示解答
因为 * 和 % 的优先级高于 +,所以 + 最后求值。表达式可改写为 6 + (5 * 4 % 3)。* 和 % 优先级相同,需要根据结合性确定顺序。它们都是从左到右结合,因此先计算左侧运算符。表达式可进一步写成:6 + ((5 * 4) % 3)。

6 + ((5 * 4) % 3) = 6 + (20 % 3) = 6 + 2 = 8

问题 #2

编写程序要求用户输入整数,并告知该数是奇数还是偶数。 编写一个名为 isEven() 的 constexpr 函数:传入整数为偶数时返回 true,否则返回 false。使用取余运算符判断整数参数是否为偶数,并确保 isEven() 对正数和负数都有效。

显示提示
提示:这个程序可能需要使用 if 语句和比较运算符(==)。如果需要复习相关内容,请参阅布尔值课程。

程序输出应与以下结果一致:

请输入整数:5
5 is odd

显示解答
C++
#include <iostream>

constexpr bool isEven(int x)
{
    // 如果 x % 2 == 0,说明 2 能整除 x,因此 x 必为偶数
    return (x % 2) == 0;
}

int main()
{
    std::cout << "请输入整数:";
    int x{};
    std::cin >> x;

    if (isEven(x))
        std::cout << x << " is even\n";
    else
        std::cout << x << " is odd\n";

    return 0;
}

注意:你可能想要像下面这样编写 isEven() 函数 例如这样:

C++
constexpr bool isEven(int x)
{
    if ((x % 2) == 0)
        return true;
    else
        return false;
}

虽然这样可行,但比必要的复杂。下面看看如何简化。首先,把 if 语句的条件提取出来,赋给单独的布尔变量:

C++
constexpr bool isEven(int x)
{
    bool isEven = (x % 2) == 0;
    if (isEven) // isEven 为 true
        return true;
    else // isEven 为 false
        return false;
}

请注意,上面的 if 语句本质上是在说:“如果 isEven 为真就返回 true,否则如果 isEven 为假就返回 false”。既然如此,直接返回 isEven 即可:

C++
constexpr bool isEven(int x)
{
    bool isEven = (x % 2) == 0;
    return isEven;
}

在本例中,由于变量 isEven 只使用一次,也可以直接删除这个变量:

C++
constexpr bool isEven(int x)
{
    return (x % 2) == 0;
}

最后更新