C++ Operators

C++ provides a rich set of operators grouped by category:

1. Arithmetic operators +, -, *, /, % — standard math operations. Integer division truncates toward zero; % is the remainder (result sign follows the dividend in C++11+).

2. Relational (comparison) operators ==, !=, <, >, <=, >= — return bool.

C++20 adds the three-way comparison (spaceship) operator <=>, which returns a comparison category (std::strong_ordering, std::weak_ordering, or std::partial_ordering) and can auto-generate all six relational operators for a class.

3. Logical operators &&, ||, ! — operate on bool values with short-circuit evaluation. && stops at the first false; || stops at the first true.

4. Bitwise operators &, |, ^, ~, <<, >> — operate on individual bits of integer types. Commonly used in embedded programming, flags, and performance-sensitive code.

5. Assignment operators = (basic), and compound: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=. Assignment returns an lvalue reference to the left operand, enabling chained assignment.

6. Increment and decrement operators ++ and --, in prefix (++i) and postfix (i++) forms. Prefix returns the updated value; postfix returns the old value (may create a temporary). Prefer prefix for iterators to avoid unnecessary copies.

7. Member access operators . (dot) for objects, -> (arrow) for pointers or smart pointers, [] for subscript access.

8. Pointer operators * (dereference), & (address-of). In modern C++ prefer smart pointers (unique_ptr, shared_ptr) over raw pointer manipulation.

9. Type operators

• sizeof — size of a type or object in bytes (compile-time)
• alignof — alignment requirement of a type (C++11)
• typeid — runtime type information
• Casts: static_cast, dynamic_cast, const_cast, reinterpret_cast

10. Other special operators

• ? : (ternary/conditional)
• , (comma — evaluates both operands, yields the right one; rarely needed)
• :: (scope resolution)
• new / delete — heap allocation/deallocation (prefer smart pointers)
• noexcept operator — tests at compile time whether an expression can throw

11. User-defined operators (operator overloading) Almost all operators can be overloaded for custom types. The spaceship operator <=> (C++20) is especially powerful: define it once and the compiler generates <, >, <=, >=, ==, != automatically.

Common interview point: Know operator precedence — especially that & has lower precedence than ==, which causes bugs like if (flags & MASK == 0) being parsed as if (flags & (MASK == 0)). Always parenthesize bitwise expressions in conditions.

Operator precedence determines which operator binds more tightly in an expression. Higher-precedence operators are evaluated first. When two operators have the same precedence, associativity (left-to-right or right-to-left) breaks the tie.

Abbreviated precedence table (highest to lowest — selected levels):

Classic example:

int result = 2 + 3 * 4;   // 14, not 20 — * binds tighter than +

Common gotchas interviewers test:

// Bitwise AND has LOWER precedence than ==
if (flags & MASK == 0)  // parsed as: flags & (MASK == 0) — almost certainly wrong
if ((flags & MASK) == 0)  // correct

// Shift has lower precedence than +
std::cout << 1 + 2 << '\n';  // prints 3, then newline — parsed as (cout << (1+2)) << '\n'

// Ternary is right-associative
int x = a ? b : c ? d : e;  // parsed as: a ? b : (c ? d : e)

Best practice: When in doubt, use parentheses to make intent explicit. Do not rely on precedence rules for expressions mixing bitwise, arithmetic, and comparison operators — parenthesize them every time. This eliminates bugs and improves readability.

C++20 note: The spaceship operator <=> sits between shift and the relational operators (<, >) in the precedence table.

The sizeof operator returns the size in bytes of a type or object as a compile-time constant of type std::size_t. It is not a function — it is evaluated entirely at compile time and produces no runtime overhead.

Syntax:

sizeof(type)       // size of a type
sizeof expression  // size of the type of an expression (parentheses optional)

Examples:

#include 
int main() {
    std::cout << sizeof(int)    << '\n';  // typically 4
    std::cout << sizeof(double) << '\n';  // typically 8
    std::cout << sizeof(char)   << '\n';  // always 1 (by definition)

    int arr[10];
    std::cout << sizeof(arr)              << '\n';  // 40 (4 * 10)
    std::cout << sizeof(arr) / sizeof(arr[0]) << '\n';  // 10 — element count

    int* p = arr;
    std::cout << sizeof(p) << '\n';  // 8 on 64-bit — size of POINTER, not array!
}

Key points interviewers probe:

• sizeof(char) is always 1 by the standard. All other sizes are implementation-defined (though int is almost universally 4 bytes on modern platforms).
• sizeof on an array gives the total byte size of the array. sizeof on a pointer to the same array gives only the pointer size — a classic source of bugs when arrays decay to pointers.
• sizeof does not evaluate its operand — there are no side effects: sizeof(i++) does not increment i.
• sizeof returns std::size_t, an unsigned type. Mixing it with signed integers in arithmetic can cause subtle bugs.
• For class types, sizeof includes padding bytes inserted by the compiler for alignment. Use offsetof (from ``) to inspect field layout.

Modern alternatives:

• std::array stores its size as a template parameter — use arr.size() instead of sizeof(arr)/sizeof(arr[0]).
• std::span (C++20) carries a size alongside a pointer, eliminating the need for sizeof arithmetic when passing arrays to functions.
• alignof(T) (C++11) returns the alignment requirement of a type, complementing sizeof.

#include 
std::array arr{};
std::cout << arr.size() << '\n';  // 10 — always correct, no sizeof trickery needed

Bitwise operators work directly on the binary representation of integer values, operating bit by bit. They are fundamental in systems programming, embedded development, flag manipulation, and performance-sensitive code.

The six bitwise operators:

Examples:

unsigned int a = 0b1010;   // 10
unsigned int b = 0b1100;   // 12

a & b;   // 0b1000 = 8  (AND)
a | b;   // 0b1110 = 14 (OR)
a ^ b;   // 0b0110 = 6  (XOR)
~a;      // 0b...11110101 (NOT — depends on type width)
a << 1;  // 0b10100 = 20 (multiply by 2)
a >> 1;  // 0b0101  = 5  (divide by 2, truncated)

Common practical patterns:

// Set a bit
flags |= (1u << bitPos);

// Clear a bit
flags &= ~(1u << bitPos);

// Toggle a bit
flags ^= (1u << bitPos);

// Test a bit
bool isSet = (flags >> bitPos) & 1u;

// Check if a value is a power of two
bool isPow2 = n > 0 && (n & (n - 1)) == 0;

Important gotchas:

• Bitwise operators on signed integers can invoke undefined behaviour (e.g., left-shifting into the sign bit). Always prefer unsigned types for bit manipulation.
• ~ on a small unsigned type (e.g., uint8_t) produces an int due to integer promotion — mask the result: uint8_t result = ~x & 0xFF;.
• C++20 defines arithmetic right shift for signed types as implementation-defined but standardises two's-complement representation for all signed integer types, removing previous ambiguity.
• << and >> have lower precedence than + but higher than == — parenthesize when combining with comparisons: (x >> 2) == 3, not x >> 2 == 3.

C++20 addition — `` header:

C++20 introduces `` with portable bit-manipulation utilities:

#include 
std::popcount(0b10110u);       // 3 — count set bits
std::countl_zero(0b00100u);    // count leading zeros
std::has_single_bit(16u);      // true — power of two check
std::rotl(x, 3);               // rotate left by 3 bits

Prefer these standard functions over hand-rolled bit tricks in new code — they are clearer, portable, and compiler-optimised.

"Special operators" in C++ refers to operators that don't fit neatly into arithmetic, relational, logical, or bitwise categories. The most commonly discussed in interviews:

1. Conditional (ternary) operator ? : The only ternary operator in C++. A compact if-else expression:

int max = (a > b) ? a : b;

Both branches must have compatible types. Prefer it for simple expressions; avoid nesting it deeply.

2. Scope resolution operator :: Accesses names in a specific namespace or class, or disambiguates the global scope:

std::cout      // name 'cout' in namespace 'std'
MyClass::func  // static member of MyClass
::globalVar    // explicit global scope

3. sizeof and alignof Compile-time unary operators returning the byte size or alignment of a type/expression. Not function calls — they produce compile-time constants.

4. new and delete Allocate and deallocate heap memory:

int* p = new int{42};
delete p;

int* arr = new int[10]{};
delete[] arr;

In modern C++, prefer std::make_unique() and std::make_shared() over raw new. Direct use of new/delete is a code smell unless writing a custom allocator.

5. Type cast operators C++ provides four named casts replacing C-style (type):

• static_cast — safe, checked at compile time (numeric conversions, up/downcasting in known hierarchies)
• dynamic_cast — runtime-checked downcast in polymorphic hierarchies; returns nullptr (pointers) or throws std::bad_cast (references) on failure
• const_cast — add or remove const/volatile only
• reinterpret_cast — low-level bit reinterpretation; dangerous, platform-dependent

6. Pointer-to-member operators .* and ->* Access a member specified by a pointer-to-member:

struct Foo { int x; };
int Foo::* mp = &Foo::x;
Foo obj{5};
int val = obj.*mp;         // 5

Rarely used directly; common in callbacks and reflection frameworks.

7. noexcept operator (C++11) Tests at compile time whether an expression is declared not to throw:

static_assert(noexcept(std::swap(a, b)));

8. Three-way comparison <=> (C++20) The "spaceship operator" returns a comparison category and auto-generates all six relational operators when defaulted:

auto operator<=>(const MyClass&) const = default;

9. co_await, co_yield, co_return (C++20) Coroutine operators that suspend and resume coroutine execution — a significant addition enabling async and generator patterns without threads.

Common interview follow-up: "When would you use dynamic_cast?" — Only when you have a pointer/reference to a base class and genuinely need to check at runtime which derived type it is. Overuse signals a design problem; prefer virtual dispatch instead.