{"title":"Operators","description":null,"content":"Operators are the symbols and keywords that do the actual work inside a C++ expression. They add up cart totals, compare product prices, decide whether an item is in stock, read through pointers, and tell the compiler which scope to look inside. C++ has more operator families than most languages, so this lesson sketches the full map first, then later lessons drill into the families that matter most day-to-day.\n\n---\n\n# How to Read This Lesson\n\nThis is the map, not the deep dive. The next two lessons go deep on arithmetic, assignment, comparison, and logical operators. Bitwise, ternary, and operator overloading each get their own treatment later. Each family gets one or two examples to make the symbol recognizable, plus the parts that are easy to misread (precedence, the comma operator, `::`, `*p++`).\n\n---\n\n# What Counts as an Operator\n\nIn C++, an operator is anything that takes one or more values (called **operands**) and produces a new value. Most operators are punctuation symbols like `+` or `<<`, but a few are keywords like `sizeof`, `new`, or `typeid`. Operators come in three arities:\n\n\n| Arity | Operands | Examples |\n|-------|----------|----------|\n| Unary | 1 | `-x`, `!ok`, `*ptr`, `&value`, `sizeof(int)` |\n| Binary | 2 | `a + b`, `price < 100`, `cart = items` |\n| Ternary | 3 | `inStock ? \"ship\" : \"wait\"` |\n\n\nC++ has exactly one ternary operator, the conditional `?:`. Everything else is unary or binary. A symbol like `*` can mean different things depending on context: as a binary operator it multiplies, as a unary operator it dereferences a pointer. The compiler decides which meaning applies based on where the symbol sits in the expression.\n\n---\n\n# The Operator Map\n\nThe families in C++, grouped by what they do:\n\n\n| Family | Operators | What they do |\n|--------|-----------|--------------|\n| Arithmetic | `+ - * / %` | Add, subtract, multiply, divide, remainder |\n| Assignment | `= += -= *= /= %= &= \\|= ^= <<= >>=` | Store a value, optionally combined with another op |\n| Increment/Decrement | `++ --` (pre and post) | Add or subtract 1 in place |\n| Comparison | `== != < > <= >=` | Test equality or ordering, produce a `bool` |\n| Logical | `&& \\|\\| !` | Combine boolean conditions, short-circuit |\n| Bitwise | `& \\| ^ ~ << >>` | Operate on the individual bits of an integer |\n| Member access | `. -> .* ->*` | Reach into a struct, class, or object through a pointer |\n| Scope resolution | `::` | Name something inside a namespace or class |\n| Address-of / Dereference | `& *` | Take the address of a value, or read through a pointer |\n| Sizeof / Alignof | `sizeof alignof` | Ask the compiler how many bytes a type occupies |\n| Conditional (ternary) | `?:` | Pick one of two values based on a condition |\n| Comma | `,` | Evaluate two expressions left to right, return the right one |\n| Type cast | `static_cast` `dynamic_cast` `const_cast` `reinterpret_cast` `(T)x` `T(x)` | Convert one type to another |\n| Allocation | `new new[] delete delete[]` | Allocate and free heap memory |\n| Identification | `typeid` | Look up runtime type information |\n| Exception | `throw` `noexcept` | Raise and check for exceptions |\n\n\nThat's a long list, but it doesn't need to be memorised. What matters is recognising that, for example, `::` is an operator, and that `sizeof` is too. Each family has its own lesson or section later in the course.\n\n---\n\n# Scope Resolution: `::`\n\n`::` already appeared in `std::cout`. It's the **scope resolution operator**, and it tells the compiler \"look inside this scope for the name on the right.\" The left side is a namespace, a class name, or empty (meaning \"the global scope\").\n\n\n```cpp\n#include \n#include \n\nnamespace store {\n int totalItems = 42;\n}\n\nint main() {\n std::vector cart; // std:: -> look inside the std namespace\n cart.push_back(3);\n std::cout << \"Cart size: \" << cart.size() << std::endl;\n std::cout << \"Store stock: \" << store::totalItems << std::endl;\n return 0;\n}\n```\n\n\n`std::vector` says \"the `vector` defined inside `std`,\" and `store::totalItems` says \"the `totalItems` defined inside `store`.\" Without `::`, the compiler doesn't know where to look and reports `error: 'vector' was not declared in this scope`.\n\n`::` shows up later in two other places: in front of a name to mean \"the one at global scope\" (e.g., `::main`), and between a class name and a member (e.g., `Cart::checkout`). Both are the same operator, with a different left side.\n\n---\n\n# Member Access: `.` and `->`\n\nGiven a `struct` or class object, the dot operator `.` reaches into it for a member. Given only a pointer to the object, the arrow operator `->` does the same thing but dereferences the pointer first.\n\n\n```cpp\n#include \n#include \n\nstruct Product {\n std::string name;\n double price;\n};\n\nint main() {\n Product item{\"Wireless Mouse\", 24.99};\n Product* ptr = &item;\n\n std::cout << item.name << \" costs $\" << item.price << std::endl;\n std::cout << ptr->name << \" also costs $\" << ptr->price << std::endl;\n return 0;\n}\n```\n\n\n`item.name` reads `name` directly from `item`. `ptr->name` is shorthand for `(*ptr).name`: first follow the pointer to the object, then read `name`. The two lines produce the same output because `ptr` points at `item`.\n\nThe symbols are what to recognize for now.\n\n---\n\n# Address-of `&` and Dereference `*`\n\nTwo more pointer-related operators show up everywhere, so they belong on the map even though their deep dive comes later.\n\n- `&value` takes the address of `value`. The result is a pointer pointing at it.\n- `*ptr` dereferences `ptr`, meaning \"read or write the value `ptr` points at.\"\n\n\n```cpp\n#include \n\nint main() {\n int stock = 50;\n int* ptr = &stock; // address-of: ptr now holds the address of stock\n std::cout << \"Direct: \" << stock << std::endl;\n std::cout << \"Through pointer: \" << *ptr << std::endl;\n *ptr = 75; // dereference: write through ptr\n std::cout << \"After update: \" << stock << std::endl;\n return 0;\n}\n```\n\n\nSame symbols, different contexts. As a binary operator, `&` is bitwise AND (`a & b`). As a unary operator in front of a variable name, it's address-of. As a binary operator, `*` is multiplication. As a unary operator in front of a pointer, it's dereference. The compiler decides which based on where the symbol sits.\n\n---\n\n# The `sizeof` Operator\n\n`sizeof` is a compile-time operator that asks \"how many bytes does this type or value occupy in memory?\" It returns a value of type `std::size_t`, an unsigned integer big enough to hold any object size on the platform.\n\n\n```cpp\n#include \n\nint main() {\n int productId = 1024;\n double price = 19.99;\n\n std::cout << \"sizeof(int): \" << sizeof(int) << \" bytes\" << std::endl;\n std::cout << \"sizeof(double): \" << sizeof(double) << \" bytes\" << std::endl;\n std::cout << \"sizeof(productId): \" << sizeof(productId) << \" bytes\" << std::endl;\n std::cout << \"sizeof price: \" << sizeof price << \" bytes\" << std::endl;\n return 0;\n}\n```\n\n\n**Output (on most 64-bit systems):**\n\n\n```shell\nsizeof(int): 4 bytes\nsizeof(double): 8 bytes\nsizeof(productId): 4 bytes\nsizeof price: 8 bytes\n```\n\n\nTwo details worth noticing. First, `sizeof` works on a type (`sizeof(int)`) or on an expression (`sizeof productId`). When given a type, parentheses are required. When given an expression, they're optional. Second, the result is determined at compile time, so it costs nothing at runtime, and the expression's operand isn't actually evaluated. Writing `sizeof(callExpensiveFunction())` does not call the function.\n\nThe exact sizes depend on the platform. On most modern desktop and server systems, `int` is 4 bytes and `double` is 8, but the standard only guarantees minimum sizes. For exact widths, use the fixed-width types from `` like `int32_t` or `int64_t`.\n\n`sizeof` is a compile-time operator that produces a constant. The operand is never evaluated at runtime, so `sizeof(arr) / sizeof(arr[0])` is a common idiom for counting array elements with zero runtime cost.\n\n---\n\n# The Comma Operator\n\nThe comma `,` is one of C++'s more unusual operators. As a binary operator, it evaluates its left side, throws away the result, evaluates its right side, and returns the right side's value.\n\n\n```cpp\n#include \n\nint main() {\n int itemsAdded = 0;\n int total = (itemsAdded = itemsAdded + 1, itemsAdded * 10);\n std::cout << \"itemsAdded: \" << itemsAdded << std::endl;\n std::cout << \"total: \" << total << std::endl;\n return 0;\n}\n```\n\n\nThe expression `(itemsAdded = itemsAdded + 1, itemsAdded * 10)` runs the assignment first (bumping `itemsAdded` to `1`), then evaluates `itemsAdded * 10` (which is `10`), and the whole comma expression equals `10`. The most common place this appears is inside a `for` loop's update clause:\n\n\n```cpp\nfor (int i = 0, j = 10; i < j; i++, j--) {\n // ...\n}\n```\n\n\nThat's a legitimate use. Other appearances of the comma operator are usually accidents.\n\nDon't confuse the **comma operator** with the **comma separator**. Commas in argument lists, initializer lists, and variable declarations are separators, not operators. They have different rules.\n\n\n```cpp\nint a = 1, b = 2; // separator (declaration), not the operator\nfoo(1, 2, 3); // separator (argument list), not the operator\nint x = (1, 2, 3); // operator: evaluates 1, then 2, then 3 -> x is 3\n```\n\n\nThe comma operator has the lowest precedence of any operator in C++, which is why expressions like `(1, 2, 3)` work without the parentheses fighting the assignment.\n\n---\n\n# The Ternary (Conditional) Operator `?:`\n\nThe conditional operator `condition ? a : b` is C++'s only ternary operator. If `condition` evaluates to `true`, the whole expression takes the value `a`. Otherwise it takes the value `b`.\n\n\n```cpp\n#include \n#include \n\nint main() {\n int cartItems = 3;\n std::string message = cartItems > 0 ? \"Ready to check out\" : \"Cart is empty\";\n std::cout << message << std::endl;\n return 0;\n}\n```\n\n\nThe ternary is handy for assigning one of two values in a single line. Treat it as \"an `if/else` that produces a value.\"\n\n---\n\n# Bitwise Operators\n\nThe bitwise operators work on the individual bits of an integer rather than on the integer's numeric value. There are six of them.\n\n\n| Operator | Name | Quick example |\n|----------|------|---------------|\n| `&` | Bitwise AND | `0b1100 & 0b1010` is `0b1000` (`8`) |\n| `\\|` | Bitwise OR | `0b1100 \\| 0b1010` is `0b1110` (`14`) |\n| `^` | Bitwise XOR | `0b1100 ^ 0b1010` is `0b0110` (`6`) |\n| `~` | Bitwise NOT | `~0b00000101` is `0b11111010` |\n| `<<` | Left shift | `1 << 3` is `8` (shifts bits left by 3) |\n| `>>` | Right shift | `16 >> 2` is `4` (shifts bits right by 2) |\n\n\n\n```cpp\n#include \n\nint main() {\n int a = 12; // 1100 in binary\n int b = 10; // 1010 in binary\n std::cout << \"a & b = \" << (a & b) << std::endl; // 1000 = 8\n std::cout << \"a | b = \" << (a | b) << std::endl; // 1110 = 14\n std::cout << \"a ^ b = \" << (a ^ b) << std::endl; // 0110 = 6\n std::cout << \"a << 2 = \" << (a << 2) << std::endl; // shift left\n std::cout << \"a >> 1 = \" << (a >> 1) << std::endl; // shift right\n return 0;\n}\n```\n\n\nBitwise operators show up in low-level code: storing several boolean flags in one integer, manipulating colors as packed RGBA values, masking off parts of a network packet, and a handful of fast tricks. They're far less common in everyday e-commerce code than arithmetic or comparisons.\n\nThe same symbols `<<` and `>>` are reused as the stream insertion and extraction operators for `std::cout` and `std::cin`. That's operator overloading, which the standard library uses to give streams an arrow-like syntax. The compiler picks the right meaning based on the operand types.\n\n---\n\n# Type Cast Operators\n\nC++ has a family of named cast operators for converting between types. They show up here just as a reminder of what each is for.\n\n\n| Cast | Use |\n|------|-----|\n| `static_cast(x)` | Compile-time conversion between related types (most common) |\n| `dynamic_cast(x)` | Safe downcast in a class hierarchy (runtime checked) |\n| `const_cast(x)` | Add or remove `const` |\n| `reinterpret_cast(x)` | Reinterpret the bit pattern as a different type (rare and dangerous) |\n| `(T)x` or `T(x)` | C-style cast. Avoid in modern C++. |\n\n\n\n```cpp\n#include \n\nint main() {\n int total = 75;\n int people = 4;\n double share = static_cast(total) / people;\n std::cout << \"Per-person share: $\" << share << std::endl;\n return 0;\n}\n```\n\n\nThe `static_cast` forces `total` to be treated as a `double` before division, which makes the result a `double` instead of integer division's truncated `18`.\n\n---\n\n# Other Operators Worth Knowing the Names Of\n\nA few more operators round out the map. They aren't needed today, but knowing they exist matters.\n\n- **`noexcept`** is both a specifier (on a function) and an operator. As an operator, `noexcept(expr)` evaluates to `true` if the compiler can guarantee that `expr` won't throw an exception, and `false` otherwise. The expression isn't actually evaluated, only inspected.\n- **`alignof`** is a compile-time operator that returns the alignment requirement of a type, again as a `std::size_t`. `alignof(double)` is typically `8` on 64-bit systems. Useful for low-level memory layout work.\n- **`typeid`** returns runtime type information for an expression. It's used with `dynamic_cast` for safe downcasting and reflection-style code.\n- **`new`** and **`delete`** allocate and free objects on the heap. They're operators, not functions, even though they look like they ought to be functions.\n- **`throw`** raises an exception.\n\nThat's everything. Once these names appear once, the chapters that go deeper fill in detail rather than introduce new concepts.\n\n---\n\n# Precedence and Associativity\n\nWhen an expression mixes several operators, the compiler has to decide what runs first. **Precedence** is the ranking. **Associativity** is the tie-breaker when two operators with the same precedence sit next to each other.\n\nThe full table from the C++ standard has 17 levels, from tightest binding to loosest:\n\n\n| Rank | Operators | Description | Associativity |\n|------|-----------|-------------|---------------|\n| 1 | `::` | Scope resolution | Left to right |\n| 2 | `a++ a-- T() T{} f() a[] . ->` | Postfix, member access, function call, subscript | Left to right |\n| 3 | `++a --a +a -a ! ~ *p &x sizeof new delete (T)x` | Unary, prefix, casts | Right to left |\n| 4 | `.* ->*` | Pointer-to-member | Left to right |\n| 5 | `* / %` | Multiplicative | Left to right |\n| 6 | `+ -` | Additive | Left to right |\n| 7 | `<< >>` | Bitwise shift | Left to right |\n| 8 | `<=>` | Three-way comparison (C++20) | Left to right |\n| 9 | `< <= > >=` | Relational | Left to right |\n| 10 | `== !=` | Equality | Left to right |\n| 11 | `&` | Bitwise AND | Left to right |\n| 12 | `^` | Bitwise XOR | Left to right |\n| 13 | `\\|` | Bitwise OR | Left to right |\n| 14 | `&&` | Logical AND | Left to right |\n| 15 | `\\|\\|` | Logical OR | Left to right |\n| 16 | `?:` `throw` `= += -= ...` | Conditional, throw, assignment | Right to left |\n| 17 | `,` | Comma | Left to right |\n\n\nThis table doesn't need to be memorised. What does help is a feel for the broad order of operations:\n\n1. `::` and member access (`. ->`) bind tightest.\n2. Unary operators (`-x`, `!ok`, `*ptr`, `&x`, `sizeof`) come next.\n3. Then arithmetic, then shifts, then comparisons, then bitwise, then logical.\n4. Assignment and the ternary are near the bottom.\n5. The comma operator is at the very bottom.\n\n### The Surprises\n\nMost precedence bugs come from a handful of common surprises:\n\n**Multiplication beats addition.** Same as ordinary math. `2 + 3 * 4` is `14`, not `20`.\n\n\n```cpp\n#include \n\nint main() {\n int x = 2 + 3 * 4;\n std::cout << x << std::endl;\n return 0;\n}\n```\n\n\n**Comparison beats bitwise.** `a & 1 == 0` does **not** check whether the low bit of `a` is zero. Because `==` binds tighter than `&`, the expression parses as `a & (1 == 0)`, which is `a & 0`, which is always `0`. To get the intended meaning, write `(a & 1) == 0`.\n\n\n```cpp\n#include \n\nint main() {\n int orderNumber = 14;\n bool wrong = orderNumber & 1 == 0; // bug! parses as orderNumber & (1 == 0)\n bool right = (orderNumber & 1) == 0; // intended meaning\n std::cout << \"wrong: \" << wrong << std::endl;\n std::cout << \"right: \" << right << std::endl;\n return 0;\n}\n```\n\n\nThe `wrong` value is `0` (false) for every `orderNumber`. The fix is parentheses around the `&` expression.\n\n**`*p++` parses unexpectedly.** Postfix `++` binds tighter than the unary `*`, so `*p++` parses as `*(p++)`. That means \"dereference `p`, then post-increment `p` to point at the next element.\" It's a common idiom for reading through an array. To pre-increment then dereference, write `*++p`. To dereference then increment what's pointed at, write `(*p)++`.\n\n\n```cpp\n#include \n\nint main() {\n int prices[3] = {10, 20, 30};\n int* p = prices;\n\n std::cout << *p++ << std::endl; // prints 10, then p moves to prices[1]\n std::cout << *p << std::endl; // prints 20\n (*p)++; // increments the value at prices[1]\n std::cout << prices[1] << std::endl;\n return 0;\n}\n```\n\n\nThis is a source of confusion for people coming from other languages. Read `*p++` carefully every time it appears, and add parentheses if there's any chance of confusion. After working through pointers, this idiom is clearer.\n\n**Logical AND binds tighter than logical OR.** `a || b && c` parses as `a || (b && c)`, not `(a || b) && c`. This usually does what's intended, but add parentheses when in doubt.\n\n\n```cpp\n#include \n\nint main() {\n bool inStock = false;\n bool isPremium = true;\n bool hasCoupon = true;\n bool canBuy = inStock || isPremium && hasCoupon;\n std::cout << canBuy << std::endl;\n return 0;\n}\n```\n\n\nThe expression parses as `inStock || (isPremium && hasCoupon)`. `isPremium && hasCoupon` is `true`, so the whole thing is `true`. For `(inStock || isPremium) && hasCoupon`, the parentheses are required.\n\n**Assignment is right-associative.** `a = b = c` parses as `a = (b = c)`, so both `a` and `b` end up with the value of `c`. This is rarely useful but occasionally surprising. The Arithmetic & Assignment lesson covers it.\n\n### When in Doubt, Add Parentheses\n\nThe precedence table rarely sits open during C++ work. The easier rule: add parentheses whenever the order of operations isn't obvious. They cost nothing, they make intent explicit, and they save the next person reading the code from looking the table up.\n\n\n```cpp\nbool eligible = (cartItems > 0) && (isPremium || cartTotal >= 100);\n```\n\n\nThat version reads cleanly without needing to remember whether `&&` binds tighter than `||`. The compiler doesn't care, but the next reader will.\n\n---\n\n# A Tiny End-to-End Example\n\nTo wrap the map up, a small program that touches several operator families: scope resolution, member access, arithmetic, comparison, logical, conditional, and assignment.\n\n\n```cpp\n#include \n#include \n\nstruct CartItem {\n std::string name;\n double price;\n int quantity;\n};\n\nint main() {\n CartItem item{\"Wireless Mouse\", 24.99, 3};\n double subtotal = item.price * item.quantity;\n bool freeShipping = subtotal >= 50.0;\n double shipping = freeShipping ? 0.0 : 5.99;\n double total = subtotal + shipping;\n\n std::cout << \"Item: \" << item.name << std::endl;\n std::cout << \"Subtotal: $\" << subtotal << std::endl;\n std::cout << \"Shipping: $\" << shipping << std::endl;\n std::cout << \"Total: $\" << total << std::endl;\n return 0;\n}\n```\n\n\nThis short program uses `::` (in `std::cout`), `.` (member access on `item`), `*` (multiplication), `>=` (comparison), `?:` (the ternary), `+` (addition), `=` (assignment), and `<<` (stream insertion). That's seven operator families on twelve lines of real code.\n\n\n```mermaid\nflowchart LR\n A[item.price * item.quantity]:::cyan --> B[subtotal]:::teal\n B --> C{subtotal >= 50.0}:::orange\n C -- true --> D[shipping = 0.0]:::green\n C -- false --> E[shipping = 5.99]:::red\n D --> F[total = subtotal + shipping]:::cyan\n E --> F\n F --> G[std::cout output]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe flowchart shows the order operations run in: multiply first, compare next, pick a shipping value with the ternary, add to get the total, print everything. The compiler enforces this order using precedence and the explicit sequence of statements.","pageType":"cpp"}

Operators

Get Premium