C++ operators: the full list with examples

C++ operators are the symbols that act on values, called operands, to give a result: 7 / 2 gives 3, and 7 > 2 gives true. They come in groups: arithmetic (+ - * / %), assignment (=, +=), increment and decrement (++, --), comparison (==, <), logical (&&, ||, !), bitwise (&, |, ^, ~, <<, >>), the conditional ?:, member access (., ->, []) and sizeof.

A whole program that works out a shopping total in cents uses seven of them, named in its comments:

#include <iostream>

int main() {
    int price = 350;      // one notebook: $3.50, in cents
    int count = 7;
    int shipping = 499;   // $4.99

    int subtotal = price * count;                           // *
    bool free_shipping = subtotal >= 2000 && count >= 2;    // >= &&
    int total = subtotal + (free_shipping ? 0 : shipping);  // + ?:

    std::cout << "subtotal: " << subtotal << " cents\n";
    std::cout << "free shipping: " << std::boolalpha
              << free_shipping << '\n';
    std::cout << "total: $" << total / 100 << '.'
              << total % 100 / 10 << total % 10 << '\n';    // / %
}

It printed subtotal: 2450 cents, free shipping: true and total: $24.50. total / 100 gave 24 because dividing two integers drops the fraction, and total % 100 gave the 50 cents left over, printed a digit at a time so that 5 cents shows as 05.

The samples are C++17, built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++), and each program printed the same on every compiler that built it. Since When lists which standard added each feature.

What are the operators in C++?

One row per group, each with an example from the samples and its result:

Rarer operators include the comma, the function call (), casts, new, delete and typeid.

Arithmetic operators and integer division

With two integers, / keeps only the whole part of the quotient and % gives the remainder. Make one operand a double, as in 7.0 / 2, to keep the fraction:

std::cout << 7 / 2 << '\n';    // 3: the fraction is dropped
std::cout << 7.0 / 2 << '\n';  // 3.5: one double is enough
std::cout << -7 / 2 << '\n';   // -3: toward zero, not -4

std::cout << 7 % 3 << '\n';    // 1
std::cout << -7 % 3 << '\n';   // -1: the sign of the left side
std::cout << 7 % -3 << '\n';   // 1

All four printed what the comments say: integer division cuts the fraction toward zero. The remainder follows from the rule that (a / b) * b + a % b equals a ([expr.mul]), so it takes the sign of the left operand, as the last two lines show. Dividing an integer by zero, with / or %, is undefined behavior: the standard places no requirement on what the program does.

Assignment, compound assignment and = vs ==

= stores the value on its right in the variable on its left, and a compound assignment operator (also called augmented assignment) such as x += 5 means x = x + 5. -=, *=, /=, %= and the bitwise &=, |=, ^=, <<= and >>= work the same way. Assignment groups from the right, so a = b = 5 is a = (b = 5), and it printed 5 5.

= is not ==. if (x = 0) stores 0 in x, then tests that 0, which counts as false:

int x = 7;
if (x = 0) {               // stores 0 in x, then tests 0: false
    std::cout << "if branch\n";
} else {
    std::cout << "else branch\n";
}
std::cout << "x is now " << x << '\n';

It printed else branch and x is now 0. All four compilers warned at the samples’ settings (/W4 for MSVC, -Wall -Wextra for the others), and Clang’s note names the fix: use '==' to turn this assignment into an equality comparison.

Increment and decrement: prefix or postfix?

++ adds 1 to a variable and -- subtracts 1. The prefix form, ++i, gives the new value; the postfix form, i++, gives the old one:

int i = 5;
int a = i++;   // a gets the old value, 5; then i is 6
int b = ++i;   // i becomes 7; b gets the new value, 7
std::cout << a << ' ' << b << ' ' << i << '\n';

It printed 5 7 7, and the same lines with j-- and --j printed 5 3 3. Prefix gives back the variable itself, already changed; postfix gives a copy of its old value (increment and decrement on cppreference). When the value is not used, as in ++i; on a line of its own, the two do the same.

Comparison operators

==, !=, <, >, <= and >= compare two values and give a bool: for 7 and 2 they gave false, true, false, true, false and true. They do not chain as in math. 1 < x < 10 compares 1 < x, a bool, with 10:

bool in_range = 1 < x < 10;      // (1 < x) < 10, true < 10
bool really = 1 < x && x < 10;   // what was meant

With x at 50, MSVC, GCC and Clang 19 compiled the first line with a warning (GCC: comparisons like 'X<=Y<=Z' do not have their mathematical meaning) and printed true false: the chain said 50 is between 1 and 10. Clang 23, at the same flags, refused to compile it. Join the two tests with &&, as the second line does.

C++20 adds the three-way comparison a <=> b, where (a <=> b) < 0 means a is less, == 0 equal and > 0 greater (Since When lists the compilers that have it).

Logical operators and short-circuit evaluation

&& (and) is true when both sides are true, || (or) when at least one is, and ! (not) turns true into false and back. && and || evaluate the left side first and skip the right side when the left side already decides the result, which is called short-circuit evaluation (logical operators on cppreference):

bool check() {
    std::cout << "check() called\n";
    return true;
}
// ...
void report(const int* p) {
    if (p != nullptr && *p > 0) {   // *p is read only if p is set
        std::cout << "in stock: " << *p << '\n';
    } else {
        std::cout << "nothing to report\n";
    }
}
// ...
bool r1 = false && check();   // check() is skipped
bool r2 = true || check();    // check() is skipped
bool r3 = true && check();    // check() runs
std::cout << std::boolalpha << r1 << ' ' << r2 << ' ' << r3 << '\n';
// ...
int stock = 7;
report(&stock);
report(nullptr);

check() called printed once, then false true true, in stock: 7 and nothing to report.

Bitwise operators and XOR (^)

Bitwise operators work on the bits of any integer type, not only int or char:

• & (and): 1 where both bits are 1.
• | (or): 1 where at least one bit is 1.
• ^ (XOR, exclusive or): 1 where exactly one bit is 1.
• ~ (not): every bit flipped.
• << and >>: the bits shifted left or right.

unsigned char a = 0b1100;
unsigned char b = 0b1010;
std::cout << std::bitset<8>(a & b) << '\n';    // and
std::cout << std::bitset<8>(a | b) << '\n';    // or
std::cout << std::bitset<8>(a ^ b) << '\n';    // xor
std::cout << std::bitset<8>(~a) << '\n';       // not
std::cout << std::bitset<8>(a << 1) << '\n';   // shift left
std::cout << std::bitset<8>(a >> 1) << '\n';   // shift right

std::cout << (2 ^ 3) << '\n';   // xor of 10 and 11, not 2 cubed

unsigned char flags = 0;
const unsigned char dark_mode = 0b0100;
flags ^= dark_mode;             // the bit goes on
std::cout << std::bitset<8>(flags) << '\n';
flags ^= dark_mode;             // and off again
std::cout << std::bitset<8>(flags) << '\n';

It printed:

00001000
00001110
00000110
11110011
00011000
00000110
1
00000100
00000000

The first six lines are the six operators in eight bits, printed through std::bitset; the figure of the three results draws only the last four bits.

^ is not a power: 2 ^ 3 printed 1, the XOR of binary 10 and 11. GCC and both Clangs warned did you mean '1 << 3' (8)? and MSVC at /W4 said nothing; for a power, call std::pow from <cmath>. XOR toggles a flag: flags ^= dark_mode turned the bit on, and the same line again turned it off.

Shifting by a negative count, or by at least the bit width of the promoted left operand (an unsigned char becomes an int), is undefined behavior ([expr.shift]).

The conditional operator, member access and sizeof

cond ? a : b gives a when the condition is true and b otherwise (the ternary operator has its own page). . reaches a member of an object, -> a member through a pointer, [] an element, *p the object a pointer points to, &x the address of x, :: a name inside a namespace or class (std::cout), and sizeof gives a size in bytes:

struct Item {
    std::string name;
    int price;
};
// ...
int count = 7;
std::cout << (count > 5 ? "many" : "few") << '\n';   // ?:

Item pen{"pen", 2};
Item* p = &pen;
std::cout << pen.name << ' ' << p->price << '\n';    // . and ->

std::vector<int> v{7, 2, 9};
std::cout << v[1] << '\n';                           // []

std::cout << sizeof(char) << '\n';                   // sizeof

It printed many, pen 2, 2 and 1. The sizes of the integer types are in C++ data types.

Which operator runs first?

Precedence decides how an expression is grouped: *, / and % before + and -, arithmetic before comparison, comparison before the bitwise &, ^ and |, then &&, then ||, and assignment after all of these (operator precedence on cppreference). So flags & dark_mode != 0 means flags & (dark_mode != 0): write (flags & dark_mode) != 0. The first program’s subtotal >= 2000 && count >= 2 needs no parentheses, while subtotal + (free_shipping ? 0 : shipping) does, because ?: comes after +. When two kinds of operator meet and you are not sure, add parentheses; the C++ operator precedence table has every level.

Common mistakes with C++ operators

Classes can give these operators a meaning of their own: operator overloading in C++ shows how. The Language section has the rest of the core language.