The remainder operator (operator%
)
The remainder operator (also commonly called the modulo operator or modulus operator) is an operator that returns the remainder after doing an integer division. For example, 7 / 4 = 1 remainder 3. Therefore, 7 % 4 = 3. As another example, 25 / 7 = 3 remainder 4, thus 25 % 7 = 4. The remainder operator only works with integer operands.
This is most useful for testing whether a number is evenly divisible by another number (meaning that after division, there is no remainder): if x % y evaluates to 0, then we know that x is evenly divisible by y.
Here are a couple runs of this program:
Enter an integer: 6 Enter another integer: 3 The remainder is: 0 6 is evenly divisible by 3
Enter an integer: 6 Enter another integer: 4 The remainder is: 2 6 is not evenly divisible by 4
Now let’s try an example where the second number is bigger than the first:
Enter an integer: 2 Enter another integer: 4 The remainder is: 2 2 is not evenly divisible by 4
A remainder of 2 might be a little non-obvious at first, but it’s simple: 2 / 4 is 0 (using integer division) remainder 2. Whenever the second number is larger than the first, the second number will divide the first 0 times, so the first number will be the remainder.
Remainder with negative numbers
The remainder operator can also work with negative operands. x % y
always returns results with the sign of x.
Running the above program:
Enter an integer: -6 Enter another integer: 4 The remainder is: -2 -6 is not evenly divisible by 4
Enter an integer: 6 Enter another integer: -4 The remainder is: 2 6 is not evenly divisible by -4
In both cases, you can see the remainder takes the sign of the first operand.
Nomenclature
The C++ standard does not actually give a name to operator%
. However, the C++20 standard does say, “the binary % operator yields the remainder from the division of the first expression by the second”.
Although operator%
is often called the “modulo” or “modulus” operator, this can be confusing, because modulo in mathematics is often defined in a way that yields a different result to what operator%
in C++ produces when one (and only one) of the operands is negative.
For example, in mathematics:
-21 modulo 4 = 3
-21 remainder 4 = -1
For this reason, we believe the name “remainder” is a more accurate name for operator%
than “modulo”.
In cases where the first operand can be negative, one must take care to note that the remainder can also be negative. For example, you might think to write a function that returns whether a number is odd like this:
However, this will fail when x is a negative odd number, such as -5
, because -5 % 2
is -1, and -1 != 1.
For this reason, if you’re going to compare the result of a remainder operation, it’s better to compare against 0, which does not have positive/negative number issues:
Best practice
Prefer to compare the result of the remainder operator (operator%
) against 0 if possible.
Where’s the exponent operator?
You’ll note that the ^ operator (commonly used to denote exponentiation in mathematics) is a Bitwise XOR operation in C++ (covered in lesson O.3 -- Bit manipulation with bitwise operators and bit masks). C++ does not include an exponent operator.
To do exponents in C++, #include the <cmath> header, and use the pow() function:
Note that the parameters (and return value) of function pow() are of type double. Due to rounding errors in floating point numbers, the results of pow() may not be precise (even if you pass it integers or whole numbers).
If you want to do integer exponentiation, you’re best off using your own function to do so. The following function implements integer exponentiation (using the non-intuitive “exponentiation by squaring” algorithm for efficiency):
Produces:
13841287201
Don’t worry if you don’t understand how this function works -- you don’t need to understand it in order to call it.
Related content
We cover asserts in lesson 9.6 -- Assert and static_assert, and constexpr functions in lesson F.1 -- Constexpr functions.
For advanced readers
The constexpr
specifier allows a function to be evaluated at compile-time if used in a constant expression; otherwise, it behaves like a regular function and is evaluated at runtime.
Warning
In the vast majority of cases, integer exponentiation will overflow the integral type. This is likely why such a function wasn’t included in the standard library in the first place.
Here is a safer version of the exponentiation function above that checks for overflow:
Quiz time
Question #2
Write a program that asks the user to input an integer, and tells the user whether the number is even or odd. Write a constexpr function called isEven()
that returns true if an integer passed to it is even, and false otherwise. Use the remainder operator to test whether the integer parameter is even. Make sure isEven()
works with both positive and negative numbers.
Your program should match the following output:
Enter an integer: 5 5 is odd