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*.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#include <iostream> int main() { std::cout << "Enter an integer: "; int x{}; std::cin >> x; std::cout << "Enter another integer: "; int y{}; std::cin >> y; std::cout << "The remainder is: " << x % y << '\n'; if ((x % y) == 0) std::cout << x << " is evenly divisible by " << y << '\n'; else std::cout << x << " is not evenly divisible by " << y << '\n'; return 0; } |

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. `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:

1 2 3 |
#include <cmath> double x{ std::pow(3.0, 4.0) }; // 3 to the 4th power |

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
#include <cstdint> // for std::int_fast64_t // note: exp must be non-negative std::int_fast64_t pow(int base, int exp) { std::int_fast64_t result{ 1 }; while (exp) { if (exp & 1) result *= base; exp >>= 1; base *= base; } return result; } |

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
#include <iostream> #include <cstdint> // for std::int_fast64_t // note: exp must be non-negative std::int_fast64_t powint(int base, int exp) { std::int_fast64_t result{ 1 }; while (exp) { if (exp & 1) result *= base; exp >>= 1; base *= base; } return result; } int main() { std::cout << powint(7, 12); // 7 to the 12th power return 0; } |

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 #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

5.4 -- Increment/decrement operators, and side effects |

Index |

5.2 -- Arithmetic operators |

Here's my take

Any feedback?

Looks good :)

Here is my take on the above question. Any critiques would be appreciated. I wrote it and made it work without looking. Although I do see how your answer is sleeker. However arent you using magic constant on line 7?

Does this tutorial cover multiprocessing? If not, then it would be a great topic to add I guess :)

Great tutorial once again :)

I've noticed that you always initialize a variable, even if gets assigned a value in the next statement:

I always do it this way:

but I would like to have my mind changed :)

1. Is my way of doing it faster than your way?

2. If the input is invalid, x becomes 0 (C++11 and up). x is therefore never uninitialized (after line 2), and can therefore not cause undefined behavior. Why initialize it in the first place then?

Sorry about my English being all over the place in this comment, English isn't my native language and I'm tired :)

1. Yes

2. If you always initialize everything, you'll never have problems with uninitialized variables. If you know what you're doing, you can skip initialization. Though, learncpp is targeted at beginners, who usually don't know what they're doing and would have a hard time debugging uninitialized variables.

Thank you. I will only leave variables uninitialised when I'm confident that it's safe (like when using std::cin afterwards).

For Question 2, int won't work for extremely large numbers like 423509285165835268358. However, humans can intuitively check the last digit. Would it be better if we take the last digit before the decimal point and see if it is even or odd?

In the Qn 2 example, if I input 423509285165835268358 or any large even number, it will return "2147483647 is odd".

`std::cin` clamps input that don't fit into the targeted type. To handle infinitely large numbers, you'd have to write a custom type.

If you just want to check if the number is odd or even, your idea of looking at the last digit suffices.

Not everything required to do this has been taught yet, but telling by your previous posts, you know more than what's been taught up to this point. Give it a try if you like to.

Instead of making a function that returns a boolean value, why don't you insert the boolean value to the if statement?

instead of:

I wish to know answer for this question as well :)

I don't know why they are simply complicating the staffs. I learned a bit C in my college book & took a look at JavaScript from Online. So I have a primary understanding in programming.

I was thinking for the solution like you provided but couldn't write it out in my IDE(the concept was in stuck in my head aimlessly :v). The way you showed it the simplest and that problem's solution should be written like this.

Thank you buddy.

This is my take on even/odd exercise.

I also have a question regarding your boolean function. Can you please explain to me what exactly it does? From what I know, it act/behave the same as an integer/float function which return a value? In this cause, would it make more sense to use an integer function to return an integer value?

`isEven` only has 2 possible outcomes. Either the value is even, or it's odd. That's what booleans are there for, they're either `true` or `false`. Using an integer for this would be very confusing, because the user of the function would have to read the definition or documentation to figure out what each value means.

So, you're saying that Boolean function is only good for if there's 2 possible outcome? What are some other way we can use boolean function as, aside from returning true or flase?

Sorry for many question.

"Boolean function" only means "a function returning a bool". There's no other meaning to it.

May I ask why you use int_fast# in this case? If it value 1, would it make sense to rather use something like int_least8_t? this will minimum memory and number range.

or maybe I fail to understand the whole code (function) you wrote with it.

`result` can have a very large value. 1 is only the initial value.

Instead of using the % operator I would like to be able to read the first bit of a variable

If the first bit of the variable is 1, the value will be odd if it is 0 it will be pair.

Example:

00000111 = 7 odd

00001101 = 13 odd

00000100 = 4 pair

10000000 = 128 pair

00000001 = 1 odd

00000010 = 2 pair

Could someone help me with the code, I don't know how to make it

will this code work same?

Here's another interesting way to solve the question by exploiting the fact that division of integers drops the fractional part.

nice catch. :-)

You were right about how i was tempted to write the code shown in Question #2.

Thats been my main concern about this whole learning experience is that i know how to utilize what ive learned and get it to work, but learning other ways to do it that are either more effecient and or "more or less complex", Are my main concern.

I need to get better at the problem solving of things and the logic of the writing the programs. I'm sure i will get better as i go but do you have a tip for me to learn better ways for me to learn how to better problem solve about how i need to setup what im about to write. its hard for me to word but i think you know what i am trying to say.

It's just like how when you learn math in school you are like i will never use this but you dont realize you actually will use it all the time because it improves your problem solving skills and the way you think about things it rewires your brain. That is what i want to get better at is coming up with better ways. maybe i just answered my own question.

But how you had shown "you may have been tempted to write it this way" and i did and sure it worked. But then you shown "well you can do this instead you dont have to itterate so much and there is an easier way to do this" thats what inspires me with coding and what i find rewarding is when i can do these little excercises and they look exactly like your solution and show me another better way i could have done it.

Hello Alex & nascardriver,

in chapter 2.11 - Header files (The #include order of header files) you wrote to sort the headers alphabetically, but the third code example from (Where’s the exponent operator?) in this chapter has iostream before cstdint.

Keep up the great work,

Andreas

#include<iostream>

bool IsEven(int x) {

if (x % 2 == 0) {

std::cout << x <<" is even to ";

}

else {

std::cout << x << " is odd to ";

}

return false;

}

int main() {

std::cout << "Enter an integer: ";

int x;

std::cin >> x;

std::cout << IsEven(x);

}

// not so perfect as your program though :(

hope this is okay

Hi Amir.

My problem with this function is that it's not intuitive for other users. The function name is "isEven", but returns 0 (false) if the number is even, and 1 (true) if the number is odd. A better name for the function would be isOdd(), but since the quiz asks for a function by the name isEven(), my solution would be as follows:

This code does what the name suggests, i.e. to evaluate whether or not the entered number is even (true/false), by using the ! (logical not) operator. It can still be a bit of a hassle to understand intuitively from an outsider's perspective by just looking at the code, which is (I assume) why Alex and Nascardriver chose their solution instead:

you right :) it makes sense . I wasn't caring that much about how to make code readable and easy to understand. Now after learning more I really see how its important to make each statement clear . thank you :)