Operators

In the last lesson you learned the types of values C++ can hold. Values alone are not enough — a program must do things with them: add them, compare them, combine them, and change them. Operators are the symbols that do this work. In this lesson you will learn the main families of operators, the rules that decide which one runs first, and the mistakes operators cause most often.

Arithmetic Operators — Doing Math

Arithmetic operators work on numbers, exactly as you would expect from school math. The one to watch is division: when both numbers are integers, C++ gives an integer answer and throws the fraction away.

#include <iostream>

int main() {
    int a = 10, b = 3;
    std::cout << "a + b = " << a + b << std::endl;
    std::cout << "a - b = " << a - b << std::endl;
    std::cout << "a * b = " << a * b << std::endl;
    std::cout << "a / b = " << a / b << std::endl;
    std::cout << "a % b = " << a % b << std::endl;
    return 0;
}

a / b is 3, not 3.33, because both numbers are integers — remember Lesson 7. If either number were a double, the answer would keep its decimals. The remainder operator % gives what is left over after division: 10 divided by 3 is 3 remainder 1. It only works on integers, and it is the standard way to test whether a number is even — a number is even when n % 2 is 0.

Assignment and Compound Assignment

The plain assignment operator = stores a value in a variable. Compound assignment combines an operation with the assignment, so the code is shorter and the intent is clearer — and there is less chance of typing the variable name wrong on one side.

#include <iostream>

int main() {
    int score = 100;
    score += 10;   // score is now 110
    score -= 25;   // now 85
    score *= 2;    // now 170
    score /= 5;    // now 34
    score %= 7;    // now 6
    std::cout << "score = " << score << std::endl;
    return 0;
}

Each line does the same as the longer form: score += 10 means exactly score = score + 10. Follow the value: 100 + 10 = 110, minus 25 = 85, doubled = 170, divided by 5 = 34, and 34 modulo 7 = 6 (because 7 goes into 34 four times, 28, leaving 6).

Increment and Decrement — ++ and --

Adding or subtracting exactly one is so common that C++ has a shortcut: ++ adds 1 and -- subtracts 1. There is a catch — it matters whether the operator comes before or after the variable.

#include <iostream>

int main() {
    int a = 5;
    int b = a++;   // b gets 5, then a becomes 6
    int c = ++a;   // a becomes 7, then c gets 7
    std::cout << "a = " << a << ", b = " << b << ", c = " << c << std::endl;
    return 0;
}

With a++ (postfix), the old value is used first and the variable is increased afterwards — so b gets 5. With ++a (prefix), the variable is increased first and the new value is used — so c gets 7. In a loop (Lesson 10) you will mostly write ++ on a line by itself, where the difference does not matter.

Comparison Operators — Asking Yes/No Questions

A comparison asks a question about two values and answers with a bool: true or false. These operators are the test in every if statement you will write, starting in the next lesson.

#include <iostream>

int main() {
    int age = 18;
    std::cout << std::boolalpha;
    std::cout << "age == 18 : " << (age == 18) << std::endl;
    std::cout << "age >= 21 : " << (age >= 21) << std::endl;
    std::cout << "age != 0  : " << (age != 0) << std::endl;
    return 0;
}

One warning that will save you hours of debugging: == compares, but a single = assigns. Writing if (age = 18) puts 18 into age and is always treated as true — the test never fails. Your compiler may warn you about it, but the best defense is to read your comparisons twice.

Logical Operators — Combining Conditions

Real decisions usually combine several conditions: old enough and holding a ticket, a child or a senior. The logical operators combine bool values into a new bool value.

#include <iostream>

int main() {
    int age = 20;
    bool hasTicket = true;
    std::cout << std::boolalpha;
    std::cout << "Can enter: " << (age >= 18 && hasTicket) << std::endl;
    std::cout << "Is a child or a senior: " << (age < 13 || age >= 65) << std::endl;
    std::cout << "Not allowed: " << !(age >= 18) << std::endl;
    return 0;
}

A bonus for professionals: && and || are "short-circuit" operators. If the left side of && is false, the right side is never evaluated — and if the left side of || is true, the right side is skipped. Programs rely on this to skip tests that would be wrong or wasteful.

Operator Precedence — Who Goes First?

When an expression has several operators, precedence decides which runs first. You already know it from school: multiplication before addition. The full order, from highest to lowest, is:

#include <iostream>

int main() {
    std::cout << "2 + 3 * 4 = " << 2 + 3 * 4 << std::endl;
    std::cout << "(2 + 3) * 4 = " << (2 + 3) * 4 << std::endl;
    std::cout << "10 - 4 / 2 = " << 10 - 4 / 2 << std::endl;
    return 0;
}

2 + 3 * 4 is 14, because * runs before +. Parentheses always win, so (2 + 3) * 4 is 20 — when in doubt, add parentheses: they cost nothing and they make your intent obvious to the next reader. Operators on the same level run left to right, except assignment, which runs right to left — so a = b = 5 gives 5 to both.

Common Mistakes with Operators

Operators are small, so their mistakes are easy to make and hard to spot. If a result looks slightly wrong, check this list first.