Search⌘ K
AI Features
Home
Courses
Master Modern C++

Arithmetic and Assignment Operators

Explore how to manipulate data using arithmetic and assignment operators in C++. Learn the rules of integer and floating-point division, use compound assignment operators for efficient updates, and understand the difference between prefix and postfix increments. Gain essential skills to perform accurate calculations and avoid common pitfalls like undefined behavior.

We'll cover the following...

Mathematics is the engine behind almost every program, whether we are calculating damage in a game, processing financial transactions, or resizing an image. C++ provides a robust set of operators to handle these tasks efficiently. However, unlike standard algebra, C++ math has specific rules regarding types and evaluation order.

In this lesson, we will learn how to manipulate data using arithmetic and assignment operators, ensuring our calculations are both correct and efficient. These are some of the most common operators in C++ and form the foundation of numeric computation and variable updates.

Basic arithmetic operators

Arithmetic operators allow programs to perform basic math operations on values, forming the foundation of most calculations. C++ provides five fundamental arithmetic operators:

  • Addition (+): It adds two values together. It is commonly used to combine values, update counters, or calculate totals.

  • Subtraction (-): It finds the difference between two values. This is often used when decreasing values or calculating remaining amounts.

  • Multiplication (*): It multiplies two values. It is useful for scaling values or performing repeated addition.

  • Division (/): It divides one value by another. Remember that when used with integers, the result is also an integer, and any decimal part is discarded. To get a decimal result, at least one operand must be a floating-point value.

  • Modulus (%): It gives the remainder after division. It works only with integers and is commonly used to check divisibility or determine whether a number is even or odd.

Let's see them in action below.

C++ 23
#include <iostream>
int main() {
    int num1 = 10;
    int num2 = 4;
    float num3 = 10;
    std::cout << "Addition:" << num1+num2 << std::endl;
    std::cout << "Subtraction:" << num1-num2 << std::endl;
    std::cout << "Multiplication:" << num1*num2 << std::endl;
    std::cout << "Integer division:" << num1/num2 << std::endl;
    std::cout << "Float division:" << num3/num2 << std::endl;
    std::cout << "Modulus:" << num1%num2;
}

  • Lines 4-6: We initialize two int type variables: num1 and num2. Next, we initialise a float type variable, num3.

  • Line 8: We add num1 and num2 using + operator and print its value directly without storing result in a separate variable.

  • Line 9: We subtract num2 from num1 using - operator and print its value directly without storing result in a separate variable.

  • Line 10: We multiply num1 with num2 using * operator and print its value directly without storing result in a separate variable.

  • Line 11: We divide num1 with num2 using / operator and print its value directly without storing result in a separate variable. Note, it prints 2 and not 2.5. That's because when / is used with integers, the result is also an integer, and any decimal part is discarded.

  • Line 12: Now, we try dividing num3 with num2 using / operator and print its value directly without storing result in a separate variable. Note, it prints 2.5. That's because to get a decimal result, at least one operand must be a floating-point value. We can also try this with double type variable.

  • Line 13: We get remainder after dividing num1 with num2 using % operator and print its value directly without storing result in a separate variable. Try replacing num1 with num3, and notice the compilation error because this this operator only works with integers.

Assignment and compound assignment

We often update a variable based on its own current value; for example:

x = x + 1;
Updating variable based on its own value

It is a very common use case. C++ provides a shortcut to write this through compound assignment operators. These operators apply the arithmetic operation and update the variable in a single step. Below table enlists commonly used compound assignment operators.

Operator

Usage

Equivalence

+=

x += y

x = x + y

-=

x -= y

x = x - y

*=

x *= y

x = x * y

/=

x /= y

x = x / y

%=

x %= y

x = x % y

Let's see them in action below:

C++ 23
#include <iostream>
int main() {
    int wallet = 100;
    wallet += 50;  // Equivalent to: wallet = wallet + 50; (150)
    wallet -= 20;  // Equivalent to: wallet = wallet - 20; (130)
    wallet *= 2;   // Equivalent to: wallet = wallet * 2;  (260)
    wallet /= 10;  // Equivalent to: wallet = wallet / 10; (26)
    
    std::cout << "Final wallet balance: " << wallet;
    return 0;
}

Let’s break this down step by step:

  • Lines 4: We declare an integer variable wallet, initializing it to 100.

  • Lines 6–9: Here, we use compound assignment operators, which combine an arithmetic operation with assignment. Each of these statements updates wallet in place.:

    • wallet += 50; adds 50 to wallet, resulting in 150.

    • wallet -= 20; subtracts 20 from the current value, resulting in 130.

    • wallet *= 2; multiplies the value by 2, resulting in 260.

    • wallet /= 10; divides the value by 10. Since wallet is an int, this is integer division, producing 26.

  • Line 11: We print the final value of wallet to the console.

Deep dive: The order of compound assignment

A common source of confusion for beginners is how compound assignment operators interact with other arithmetic on the same line. Take this expression as an example:

x += 5 * 2;

At first glance, you might wonder whether this means (x + 5) * 2 or x + (5 * 2). The correct interpretation is the second one. In C++, the entire right-hand side (RHS) is evaluated first, and only then is the compound assignment applied. This happens because compound assignment operators like += and *= have very low precedence.

So in the case of x += 5 * 2, the compiler first evaluates 5 * 2, which results in 10. Only after that does it apply the compound operation, effectively turning the statement into x = x + 10. If x started as 10, the final result is 20.

This rule holds even when the right-hand side contains operators with lower precedence, such as addition. Consider this example:

int y = 4;
y *= 2 + 3;

It’s easy to mistakenly read this as y = y * 2 + 3, which would evaluate to 11. However, that’s not what happens. Instead, the expression 2 + 3 is evaluated first, producing 5. Then the compound assignment is applied, resulting in y = 4 * 5, which gives 20.

A helpful way to think about compound assignment is to imagine implicit parentheses around the entire right-hand side. In other words, y *= 2 + 3 behaves as if it were written y *= (2 + 3). Keeping this mental model in mind can help you avoid subtle and confusing bugs.

Increment and decrement operators

Adding or removing 1 is the most frequent math operation in programming. C++ provides dedicated operators for this:

  • Increment (++): Adds 1 to a variable.

  • Decrement (--): Subtracts 1 to a variable.

These come in two forms: prefix and postfix. Prefix means to increment/decrement the variable first, then returns the new value. It's also read as, "Change, then use." Whereas, postfix means to makes a copy of the old value, increments the variable, then returns the copy. It's read as, "Use, then change."

C++ 23
#include <iostream>
int main() {
    int a = 5;
    int b = 5;
    int prefix_result = ++a;  // Increment 'a' to 6, assign 6 to result
    int postfix_result = b++; // Assign 5 to result, THEN increment 'b' to 6
    std::cout << "a: " << a << ", prefix: " << prefix_result <<std::endl;
    std::cout << "b: " << b << ", postfix: " << postfix_result <<std::endl;
}

Let’s break this down into steps:

  • Lines 7–8: These lines demonstrate the difference between prefix and postfix increment operators:

    • ++a is the prefix increment. The value of a is incremented before it is used, so a becomes 6, and prefix_result receives 6.

    • b++ is the postfix increment. The current value of b is used first, so postfix_result receives 5, and then b is incremented to 6.

  • Lines 10–11: We print the final values of a and b, along with the values that were assigned during the increment operations. This clearly shows how prefix and postfix increments behave differently.

Try replacing ++ with the decrement operator to see the updated results.

Undefined behavior: The side effect trap

A "side effect" is any modification of a variable (like ++ or =). In C++, never modify the same variable twice in a single statement. The compiler does not guarantee the order of operations, leading to an undefined behavior.

C++ 23
#include <iostream>
int main() {
    int i = 0;
    // DANGEROUS: Do not do this.
    // The compiler might increment 'i' before or after the addition.
    // Results are unpredictable.
    int result = i++ + i;
    
    std::cout << "Result: " << result;
}

This code is dangerous because the variable i is modified and read in the same expression: i++ + i. The compiler is allowed to evaluate parts of this expression in different orders, so it’s unclear whether i is incremented before or after it’s used in the addition. This makes the result unpredictable and dependent on the compiler.

The golden rule: Never modify a variable more than once in a single expression, and do not use a variable that is being modified in the same expression.

Operator of precedence

Operator precedence is about grouping. It determines how an expression is parsed and which operators bind more tightly than others. It affects how the expression is interpreted, not the sequence in which code runs. For example,

C++ 23
#include <iostream>
int main() {
    int a = 2;
    int b = 3;
    int c = 4;
    int result1 = a + b * c;
    int result2 = (a + b) * c;
    
    std::cout << result1 << std::endl;
    std::cout << result2 << std::endl;
    return 0;
}

  • Line 8: In the expression a + b * c, multiplication has higher precedence than addition, so b * c is grouped together first.

  • Line 9: In case, we want to group a + b first, we need to enclose it in parentheses. Remember that () has the highest precedence amongst any of the arithmetic operators.

Summary of best practices

  1. Use parentheses: Don't memorize the entire precedence table. If you write a + b & c, use parentheses (a + b) & c to be sure.

  2. Compound assignment is safe: x *= a + b safely calculates a + b first.

  3. Prefix over postfix: Prefer ++i unless you explicitly need the old value.

We now possess the tools to calculate, count, and manipulate data precisely. We understand the specific behaviors of integer versus floating-point division and how to use increment operators safely. In the next lesson, we will combine these math skills with logical operators to make decisions in our code.