C++ Modulus

The % operator is the built-in arithmetic remainder operator in C++. It evaluates to the remainder of the division of the left-hand operand (dividend) by the right-hand operand (divisor).

auto result = lhs % rhs;

Operand Constraints

Strictly, both operands must be of integral types (e.g., int, char, long, unsigned) or unscoped enumeration types. Attempting to use the % operator with floating-point types (float, double) will result in a compilation error. Floating-point remainders require the <cmath> library function std::fmod.

Evaluation Rules and Mechanics

1. Standard Arithmetic Conversions Before the operation is performed, C++ applies standard arithmetic conversions to the operands to determine a common type. The result of the % operation is returned as this common type. 2. Sign Semantics (C++11 and later) Since C++11, integer division is strictly defined to truncate towards zero. Because the language guarantees the algebraic identity (a / b) * b + a % b == a, the sign of the remainder is strictly determined by the sign of the dividend (lhs). The sign of the divisor (rhs) has no effect on the sign of the result.

If lhs is positive, the result is positive or zero.
If lhs is negative, the result is negative or zero.

3. Undefined Behavior The % operator can invoke undefined behavior (UB) in two specific scenarios:

Division by Zero: If the right-hand operand (rhs) evaluates to 0.
Signed Integer Overflow: If the quotient of lhs / rhs is not representable in the result type, the behavior of both lhs / rhs and lhs % rhs is undefined. Consequently, evaluating the minimum representable value of any signed integer type modulo -1 (e.g., INT_MIN % -1) results in undefined behavior due to signed integer overflow.

Syntax and Behavior Visualization

#include <iostream>
#include <climits>

int main() {
    // Standard evaluation
    int a = 10 % 3;  // Evaluates to 1
    int b = 10 % 5;  // Evaluates to 0
    
    // Sign semantics (Sign matches the left-hand operand)
    int c =  10 %  3; // Evaluates to  1
    int d = -10 %  3; // Evaluates to -1
    int e =  10 % -3; // Evaluates to  1
    int f = -10 % -3; // Evaluates to -1

    // Type promotion
    int   x = 10;
    long  y = 3L;
    auto  z = x % y;  // Evaluates to 1L. Type of z is 'long'
    
    // Compilation Error: Invalid operands
    // double err = 10.5 % 2.0; 
    
    // Undefined Behavior
    // int ub1 = 10 % 0; 
    // int ub2 = INT_MIN % -1;

    return 0;
}

Compound Assignment

The % operator can be combined with the assignment operator as %=. The expression a %= b is semantically equivalent to a = a % b, except that the operand a is evaluated only once.

int val = 10;
val %= 3; // val is now 1

Tired of Poor C++ Skills? Fix That With Deep Grasping!Learn More

Functions

Templates

Constructors

Destructors

Class Types

Class Variants

Lambdas

Coroutines

Pointers & References

Variables

Member Variables

Structured Bindings

Parameters

Error Handling

Enumerations

Namespaces

Selection Statements

Loops

Modules

Attributes

Fundamental Types

Include Directives

Comments

Memory Operators

Type Cast Operators

Access Operators

Increment & Decrement Operators

Unary Operators

Comparison Operators

Logical Operators

Conditional & Comma Operators

Arithmetic Operators

Assignment Operators

Bitwise Operators

Operand Constraints

Evaluation Rules and Mechanics

Syntax and Behavior Visualization

Compound Assignment

​Operand Constraints

​Evaluation Rules and Mechanics

​Syntax and Behavior Visualization

​Compound Assignment

Operand Constraints

Evaluation Rules and Mechanics

Syntax and Behavior Visualization

Compound Assignment