# 5.3 — Modulus and Exponentiation

The modulus operator

The modulus operator (also informally known as the remainder 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. Modulus only works with integer operands.

Modulus is most useful for testing whether a number is evenly divisible by another number: 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
```

Modulus with negative numbers

The modulus operator can also work with negative operands. As of C++11, `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.

Warning

Prior to C++11, modulus with a negative operand could result in either a positive or negative result. This was made predictable in C++11.

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):

Don’t worry if you don’t understand how this function works -- you don’t need to understand it in order to call it.

Produces:

```13841287201
```

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.

Quiz time

Question #1

What does the following expression evaluate to? `6 + 5 * 4 % 3`

Show Solution

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 function called isEven() that returns true if an integer passed to it is even, and false otherwise. Use the modulus operator to test whether the integer parameter is even.

Hint: You’ll need to use if statements and the comparison operator (==) for this program. See lesson 4.9 -- Boolean values if you need a refresher on how to do this.

Your program should match the following output:

```Enter an integer: 5
5 is odd
```

Show Solution 5.4 -- Increment/decrement operators, and side effects Index 5.2 -- Arithmetic operators

### 23 comments to 5.3 — Modulus and Exponentiation

• giang

So can we use the pow() function for integers?? Because I try this function for integers and it worked

• nascardriver

`std::pow` only operates on floating point numbers.

• Kyle

I did it different than you but ended up with the same results, is this fine? I am also a lot more comfortable with the way I did when compared to the way you did it, is that bad and should I try to change that mindset? I would also like to thank you for this book as I'm going to call it, it has been a God send.

• Kyle

I was examining question 2 again and I just realized you requested that we make a function that returns true or false, I missed that. Never mind my bit of code.

• nascardriver

Your code still shows that you understand the concepts asked for in this quiz. If your program prints anything, it's good to print a line feed (\n) at the end to prevent mixing output with other programs.

• Kyle

Thank you so much for your feedback. I normally do put '\n' at the end of my prints but I often forget to, this was one of those cases.

• chai

A little bit shorter but just as good?

• nascardriver

You're converting from int to bool. It does what it should, but can be harder to read than an explicit conversion via `==`.

• koe

Would this code be slower than the quiz solution, or is it just a matter of clarity?

• nascardriver

It will probably produce exactly the same binary as the quiz. Your compiler is great at optimizing simple things. Do what you find easier to read, I prefer the comparison to 0.

• Raul

Thanks for the well-structured material!
My approach:

• nascardriver

hi Raul!

`isEven` isn't supposed to print anything, but return false/true depending on whether or not `x` is even. Try to implement it in a way that `main` does the printing.

• Raul

Thanks for the intervention, nascardriver.

• nascardriver

That's it, good job! `isEven` can be simplified even further, have a look at the solution for an explanation.

• Alex3>

This is my way of solving this task:

• nascardriver

Hi!

You're not using the return value of `isTrue`. Declare it `void`.
`std::cin >> x` should be on its own line for better readability.
If your program prints anything, the last thing it prints should be a line feed.
"isTrue" is a poor name, it doesn't describe what the function does.

• Knight

How to fix this code? 0 appeared on the result.  Thanks.

• nascardriver

`isEven` always returns `false` (Line 11). It appears you don't want to use the return value at all. Declare `isEven` `void` and don't print in line 20.
Return values are covered in lesson 2.2.

• Knight

Thanks, Nascardriver. I should read carefully and slowly.

• Ged

Why do we need to write std:: for pow? Cause it allows us to use it without std. Both codes work.

• nascardriver

declares its contents inside the `std` namespace. It also declares them outside for C compatibility, so you can use them without `std::`. To prevent name collisions and to make sure your code still works if the outside-declaration should ever be removed, I recommend using `std::pow`.

• Hadal

You forgot to include the word 'evenly' in the code output examples.

• Alex

Fixed. Thanks!