{"title":"If-Else Statements","description":null,"content":"A program that only runs straight through, top to bottom, can't react to anything. Real programs need to make decisions: charge shipping if the cart total is below a threshold, apply a discount if the customer is a member, refuse the order if a product is out of stock. The `if` statement is the simplest tool C++ gives you for that, and this lesson covers how it works, the variations you'll meet (`else`, `else if`, nested, with initializer), and the small set of mistakes that bite almost every new C++ programmer.\n\n---\n\n# The `if` Statement\n\nAn `if` statement runs a block of code only when a condition is true. The shape is:\n\n\n```cpp\nif (condition) {\n // runs when condition is true\n}\n```\n\n\nThe condition lives inside the parentheses. The body lives inside the curly braces. If the condition evaluates to `true`, the body runs. If not, the body is skipped, and execution continues after the closing brace.\n\nHere's the smallest useful example, deciding whether to charge shipping based on the cart total:\n\n\n```cpp\n#include \n\nint main() {\n double cartTotal{42.50};\n\n if (cartTotal < 50.0) {\n std::cout << \"Shipping fee: $5.99\" << std::endl;\n }\n\n std::cout << \"Order total: $\" << cartTotal << std::endl;\n return 0;\n}\n```\n\n\nThe condition `cartTotal < 50.0` evaluates to `true`, so the shipping message prints. If you change `cartTotal` to `75.0`, the `if` body is skipped and only the order total line runs. The line after the closing brace runs every time, because it sits outside the `if`.\n\nThe condition can be any expression that produces a value the compiler can convert to `bool`. A comparison like `cartTotal < 50.0` produces a `bool` directly. So does `isMember == true`, or `stockCount > 0`. We'll see in a moment that other expressions also work, including some you might not expect.\n\n---\n\n# What Counts as Truthy in C++\n\nThe condition of an `if` is converted to `bool` before it's tested. For `bool` values that's a no-op, but C++ also lets a handful of other types convert. Here are the rules you'll meet most often:\n\n- For **integer types** (`int`, `short`, `long`, `char`), `0` converts to `false` and any non-zero value converts to `true`.\n- For **floating-point types** (`float`, `double`), `0.0` converts to `false` and any non-zero value converts to `true`. Watch out for very small values near zero, they still count as `true`.\n- For **pointers**, a null pointer (`nullptr` or `NULL`) converts to `false`. Any non-null pointer converts to `true`.\n- For **`bool`**, no conversion needed: `true` is `true`, `false` is `false`.\n\nThis implicit conversion is why the following two `if` statements behave the same way:\n\n\n```cpp\n#include \n\nint main() {\n int stockCount{7};\n\n if (stockCount) {\n std::cout << \"In stock (implicit)\" << std::endl;\n }\n\n if (stockCount != 0) {\n std::cout << \"In stock (explicit)\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nBoth print. The first `if` converts `stockCount` (a non-zero `int`) to `true`. The second compares it to `0` explicitly. The implicit form is shorter, but the explicit form makes intent obvious. For numeric values that conceptually represent counts, most modern style guides prefer the explicit form (`stockCount != 0` or `stockCount > 0`). For pointers, the short form `if (ptr)` is idiomatic and you'll see it everywhere.\n\nStrings are a small trap here. A `std::string` does **not** implicitly convert to `bool`. To check whether a string is empty, call `.empty()`:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string customerName{};\n\n if (customerName.empty()) {\n std::cout << \"No customer name on file\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nA C-style string (`const char*`) is a pointer, so it does convert: a null `const char*` is `false`, and any non-null pointer (including one pointing at an empty `\"\"` string) is `true`. That mismatch between `const char*` and `std::string` catches people now and then.\n\n---\n\n# `if` with `else`\n\nAn `if` on its own only handles one path. When you want to do one thing if the condition is true and a different thing if it's false, add an `else`:\n\n\n```cpp\nif (condition) {\n // runs when condition is true\n} else {\n // runs when condition is false\n}\n```\n\n\nThe `else` block runs only when the `if` condition was `false`. Exactly one of the two blocks runs every time, never both, never neither.\n\nA shipping calculator that picks between two messages:\n\n\n```cpp\n#include \n\nint main() {\n double cartTotal{75.0};\n\n if (cartTotal < 50.0) {\n std::cout << \"Shipping fee: $5.99\" << std::endl;\n } else {\n std::cout << \"Free shipping\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nWith `cartTotal` at `75.0`, the condition `cartTotal < 50.0` is `false`, so the `else` block runs. Change the total to `42.50` and the first block runs instead. The two branches are mutually exclusive.\n\nA common shape is a small validation: if a value is bad, complain; otherwise carry on.\n\n\n```cpp\n#include \n\nint main() {\n int stockCount{0};\n\n if (stockCount > 0) {\n std::cout << \"Add to cart\" << std::endl;\n } else {\n std::cout << \"Out of stock\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\n---\n\n# `else if` Chains\n\nTwo paths cover a lot of cases, but not all. Sometimes you want to pick between three or more options. For that, chain `else if`:\n\n\n```cpp\nif (condition1) {\n // runs when condition1 is true\n} else if (condition2) {\n // runs when condition1 is false AND condition2 is true\n} else if (condition3) {\n // runs when condition1 and condition2 are false AND condition3 is true\n} else {\n // runs when none of the conditions were true\n}\n```\n\n\nThe conditions are checked in order, top to bottom. As soon as one of them is `true`, that block runs and the rest of the chain is skipped. If none match, the final `else` block runs (or nothing runs, if there's no `else`).\n\nA discount tier calculator based on cart total:\n\n\n```cpp\n#include \n\nint main() {\n double cartTotal{125.0};\n double discountRate{0.0};\n\n if (cartTotal >= 200.0) {\n discountRate = 0.20;\n } else if (cartTotal >= 100.0) {\n discountRate = 0.10;\n } else if (cartTotal >= 50.0) {\n discountRate = 0.05;\n } else {\n discountRate = 0.0;\n }\n\n std::cout << \"Discount: \" << (discountRate * 100) << \"%\" << std::endl;\n return 0;\n}\n```\n\n\n`cartTotal` is `125.0`. The first check (`>= 200.0`) is `false`. The second check (`>= 100.0`) is `true`, so the 10% branch runs and the chain stops there. The compiler doesn't even evaluate the `>= 50.0` check, because the chain is already done.\n\nThe order of the checks matters when the conditions overlap. Here, `125.0` satisfies both `>= 100.0` and `>= 50.0`, but we want the higher discount tier to win. Writing the conditions from highest to lowest threshold (or most-specific to least-specific) handles that cleanly. Reverse the order and the result changes:\n\n\n```cpp\n// Bug: 125.0 matches the first check and stops there\nif (cartTotal >= 50.0) {\n discountRate = 0.05;\n} else if (cartTotal >= 100.0) {\n discountRate = 0.10;\n}\n```\n\n\nNow a cart of `125.0` quietly gets the 5% tier, because `>= 50.0` is already `true`. The `else if` for `>= 100.0` never runs. The bug is silent: no compile error, no runtime crash, just the wrong discount. Always think through the order when conditions overlap.\n\n\n> **INFO**\n>\n> **Note:** The `switch` statement, covered in the next lesson, is sometimes a cleaner way to handle a chain of comparisons against a single value, but it only works for integer-like types. For range checks like this one, `else if` is still the right tool.\n\n\n---\n\n# Nested `if` Statements\n\nYou can put an `if` inside another `if`. The inner one only runs when the outer condition is true, which lets you check two related conditions one after the other.\n\n\n```cpp\n#include \n\nint main() {\n int stockCount{5};\n bool isMember{true};\n\n if (stockCount > 0) {\n if (isMember) {\n std::cout << \"Member price applies\" << std::endl;\n } else {\n std::cout << \"Regular price applies\" << std::endl;\n }\n } else {\n std::cout << \"Out of stock\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nThe outer `if` checks whether the product is in stock. Only if it is, the inner `if` decides which price to show. The `else` of the outer `if` handles the out-of-stock case, regardless of membership.\n\nYou can nest as deep as you want, but the readability falls off fast. Three or four levels of nesting is usually a sign that the logic should be flattened, either by combining conditions with `&&` and `||`, or by returning early from a function. Compare the version above with this flattened one:\n\n\n```cpp\n#include \n\nint main() {\n int stockCount{5};\n bool isMember{true};\n\n if (stockCount <= 0) {\n std::cout << \"Out of stock\" << std::endl;\n } else if (isMember) {\n std::cout << \"Member price applies\" << std::endl;\n } else {\n std::cout << \"Regular price applies\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nSame behavior, less nesting. Both versions are valid; the second one is easier to scan because each path is one level deep.\n\n### Braces and Scope in Nested Blocks\n\nEach `if` body has its own block, and any variable you declare inside that block is only visible there. The same scope rule applies to the bodies of `if`, `else if`, and `else`.\n\n\n```cpp\n#include \n\nint main() {\n double cartTotal{120.0};\n\n if (cartTotal >= 100.0) {\n double discount{cartTotal * 0.10};\n std::cout << \"You save: $\" << discount << std::endl;\n }\n\n // discount is not visible here\n std::cout << \"Total before any discount: $\" << cartTotal << std::endl;\n return 0;\n}\n```\n\n\n`discount` lives only inside the `if` body. Reading it after the closing brace is a compile error: the name is no longer in scope.\n\n---\n\n# One-Line `if` Without Braces\n\nC++ lets you skip the braces when the `if` body is a single statement:\n\n\n```cpp\nif (stockCount > 0)\n std::cout << \"Available\" << std::endl;\n```\n\n\nThat compiles and runs exactly like the braced version. But the moment you add a second statement, the meaning silently changes:\n\n\n```cpp\nif (stockCount > 0)\n std::cout << \"Available\" << std::endl;\n std::cout << \"Adding to cart\" << std::endl; // always runs!\n```\n\n\nThe indentation makes both lines look like they belong to the `if`, but they don't. Only the first statement is part of the `if`. The second statement is outside it and runs every time, regardless of the condition. The compiler doesn't care about indentation, only about braces.\n\nThis is a famous source of bugs, infamous enough to have caused a real-world security vulnerability (the \"goto fail\" bug in Apple's SSL code in 2014, which used the same shape of mistake). The simple rule is: **always use braces, even for single-statement bodies.** It costs you two characters and prevents an entire category of errors.\n\n\n```cpp\nif (stockCount > 0) {\n std::cout << \"Available\" << std::endl;\n std::cout << \"Adding to cart\" << std::endl;\n}\n```\n\n\nNow both lines clearly belong to the `if`, and if you later add a third, it sits inside the braces with the rest. Some compilers (recent g++ and clang++ with `-Wmisleading-indentation`) will warn you about the un-braced version, but the warning is not guaranteed. Brace every branch and the problem goes away.\n\n---\n\n# Common Mistakes\n\nA few specific mistakes show up so often that they're worth naming explicitly.\n\n### `=` vs `==`\n\n`=` is assignment. `==` is equality comparison. They look similar and they mean very different things.\n\n\n```cpp\n#include \n\nint main() {\n int stockCount{0};\n\n if (stockCount = 5) { // assigns 5 to stockCount, then tests 5 as truthy\n std::cout << \"In stock\" << std::endl;\n }\n\n std::cout << \"Stock count is now: \" << stockCount << std::endl;\n return 0;\n}\n```\n\n\nThe `if (stockCount = 5)` is almost certainly a typo for `if (stockCount == 5)`. The buggy version assigns `5` to `stockCount`, then uses the result of the assignment (`5`) as the condition. Since `5` is non-zero, the `if` body runs every time, and as a bonus the variable's value is silently overwritten.\n\nThis is one of the oldest C and C++ bugs. Most modern compilers warn about it (g++ with `-Wall` will say something like `warning: suggest parentheses around assignment used as truth value`), but the code still compiles. The fix is the equality operator:\n\n\n```cpp\nif (stockCount == 5) {\n std::cout << \"Exactly 5 in stock\" << std::endl;\n}\n```\n\n\nSome developers write the constant on the left side (`if (5 == stockCount)`) so that a typo becomes a compile error (`if (5 = stockCount)` won't compile, because you can't assign to a literal). It's a defensive habit. Modern style guides are split on whether it's worth the awkwardness.\n\n### Accidental Semicolon After `if (...)`\n\nA semicolon ends a statement. If you put one right after the parentheses of an `if`, you've ended the statement with an empty body, and the next block runs unconditionally:\n\n\n```cpp\n#include \n\nint main() {\n int stockCount{0};\n\n if (stockCount > 0); // empty body!\n {\n std::cout << \"Available\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nThe `if (stockCount > 0);` is a complete statement with an empty body. The block that follows is just a regular block (not attached to the `if`), and its body runs no matter what. The output prints even though the stock is zero.\n\nThe semicolon is invisible in casual reading, which is what makes the bug nasty. Compilers like g++ warn about this with `-Wall` (`warning: this 'if' clause does not guard...`), but again, the warning isn't required. Treat the rule \"no semicolon after a control-flow header\" as a hard habit.\n\n### The Dangling Else\n\nWhen you have a chain of `if`s without explicit braces, an `else` always attaches to the nearest unmatched `if`. Always. Even if the indentation suggests otherwise:\n\n\n```cpp\n#include \n\nint main() {\n int stockCount{0};\n bool isMember{true};\n\n if (stockCount > 0)\n if (isMember)\n std::cout << \"Member price\" << std::endl;\n else\n std::cout << \"Out of stock\" << std::endl;\n\n return 0;\n}\n```\n\n\n(The program prints nothing.)\n\nThe indentation makes it look like the `else` belongs to the outer `if (stockCount > 0)`, but it actually attaches to the inner `if (isMember)`. So when `stockCount` is `0`, the outer `if` is false, the whole inner construct is skipped, and the `else` never runs. The \"Out of stock\" message never prints, even though that's clearly what the author intended.\n\nThis is the **dangling-else problem**, and the fix is the same fix as for the one-line `if`: brace every branch. With braces, the structure is unambiguous and the parser has no choice:\n\n\n```cpp\n#include \n\nint main() {\n int stockCount{0};\n bool isMember{true};\n\n if (stockCount > 0) {\n if (isMember) {\n std::cout << \"Member price\" << std::endl;\n }\n } else {\n std::cout << \"Out of stock\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nSame logic, but now the `else` clearly belongs to the outer `if`, and the right message prints. Bracing every branch is one of the few habits in C++ that prevents multiple distinct bugs at once.\n\n---\n\n# The Decision Flow\n\nIt helps to picture an `if`/`else if`/`else` chain as a single decision flow. Each diamond is a condition that's checked in order, and the first one that's true wins.\n\n\n```mermaid\nflowchart TD\n A[Start: evaluate
cartTotal]:::cyan --> B{>= 200.0?}:::orange\n B -->|Yes| C[20% discount]:::green\n B -->|No| D{>= 100.0?}:::orange\n D -->|Yes| E[10% discount]:::green\n D -->|No| F{>= 50.0?}:::orange\n F -->|Yes| G[5% discount]:::green\n F -->|No| H[No discount]:::red\n C --> I[Continue]:::teal\n E --> I\n G --> I\n H --> I\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diagram traces the discount-tier example from earlier. The check on the cart total flows down through the diamonds in source-code order. As soon as one diamond answers `Yes`, the corresponding action runs and the rest of the chain is skipped. The final `No discount` branch represents the `else`, the catch-all that runs when every preceding condition was false.\n\nThat short-circuit behavior is built into the language. The compiler doesn't waste cycles checking `>= 50.0` after `>= 100.0` already matched. The chain stops at the first match.\n\n---\n\n# `if` with Initializer (C++17)\n\nC++17 added a useful variant: you can declare and initialize a variable as part of the `if` header, scoped to the `if` block:\n\n\n```cpp\nif (initializer; condition) {\n // body\n}\n```\n\n\nThe variable lives for the whole `if`/`else` construct, including the `else` branch, and is destroyed when the construct ends. This is handy when you need a value just to test it and use it inside the branch, without polluting the surrounding scope.\n\nA classic case is checking whether a map lookup found anything:\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n std::map stock{\n {\"Wireless Mouse\", 12},\n {\"Keyboard\", 0},\n {\"Monitor\", 3}\n };\n\n if (auto it = stock.find(\"Wireless Mouse\"); it != stock.end()) {\n std::cout << it->first << \": \" << it->second << \" in stock\" << std::endl;\n } else {\n std::cout << \"Product not found\" << std::endl;\n }\n\n // 'it' is no longer in scope here\n return 0;\n}\n```\n\n\n`stock.find` returns an iterator. The traditional pre-C++17 version had to declare `it` before the `if`, where it would linger after the `if` ended, available to be used (or misused) anywhere later in the function. The initializer form keeps `it` tightly scoped to the `if`/`else`, which matches your intent: the variable is only needed for the decision.\n\nThe same idea works with any return value you want to test. For example, opening a file:\n\n\n```cpp\n#include \n#include \n\nint main() {\n if (std::ifstream orderFile{\"orders.txt\"}; orderFile.is_open()) {\n std::cout << \"Order file opened\" << std::endl;\n } else {\n std::cout << \"Could not open order file\" << std::endl;\n }\n\n return 0;\n}\n```\n\n\nThe `orderFile` variable lives for the duration of the `if`/`else`. When the construct ends, its destructor runs and the file is closed automatically. Tight scope, automatic cleanup.\n\n---\n\n# A Note on `if constexpr`\n\nC++17 also introduced `if constexpr`, which looks similar but does something different. It's a compile-time `if`: the compiler picks one branch and discards the other entirely, based on a condition that must be known at compile time. It's mostly used in templates, where you need different code paths for different types.\n\nWe're not going to teach `if constexpr` here. It's a more advanced feature you'll meet after templates. For now, just know that the regular `if` covered in this lesson is a runtime decision, evaluated each time the code runs.\n\n---\n\n# Putting It Together\n\nOne last example that exercises several of the variations together, the kind of small check you'd write in a real ordering function:\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n std::map stock{\n {\"Wireless Mouse\", 7},\n {\"USB-C Cable\", 0}\n };\n\n std::string requested{\"Wireless Mouse\"};\n int quantity{2};\n bool isMember{true};\n\n if (auto it = stock.find(requested); it == stock.end()) {\n std::cout << \"Product not in catalog\" << std::endl;\n } else if (it->second == 0) {\n std::cout << \"Out of stock\" << std::endl;\n } else if (it->second < quantity) {\n std::cout << \"Only \" << it->second << \" available\" << std::endl;\n } else {\n double pricePerItem{29.99};\n double total{pricePerItem * quantity};\n\n if (isMember) {\n total *= 0.90;\n }\n\n std::cout << \"Order placed for \" << quantity << \" x \"\n << requested << \" - total: $\" << total << std::endl;\n }\n\n return 0;\n}\n```\n\n\nThe outer `if`/`else if`/`else` checks three different failure modes (not in catalog, out of stock, not enough stock) and falls through to the success branch only when all three are clear. The iterator `it` is scoped to the `if` block thanks to the initializer form. Inside the success branch, a small nested `if` adjusts the total for members. Every branch is braced, so there's no ambiguity about which `else` belongs to which `if`, and there's nowhere for a stray semicolon or one-line typo to cause trouble.\n\n---\n\n# Summary\n\n- An `if` statement runs a block only when its condition evaluates to `true`. Add `else` for a two-way decision, and chain `else if` for three or more.\n- The condition is converted to `bool`. Any non-zero number or non-null pointer is `true`; zero and null are `false`. `std::string` does not implicitly convert; use `.empty()` instead.\n- `else if` chains check conditions in source order and stop at the first match. When the conditions overlap, write them from most-specific to least-specific.\n- Always brace every branch of every `if`. Bracing prevents the dangling-else bug, prevents the one-line-becomes-two-lines bug, and makes intent unambiguous.\n- The most common typos are `=` instead of `==`, and a stray semicolon right after `if (...)`. Both compile, both behave wrongly, and both are flagged by `-Wall` warnings.\n- Variables declared inside an `if` body live only inside that body. They're destroyed when execution leaves the block.\n- `if` with initializer (C++17) declares a variable scoped to the `if`/`else` construct, perfect for iterators returned by `find` or RAII objects like file streams.\n- `if constexpr` is a related compile-time form used in templates; the Modern C++ Features section covers it once you've seen templates.\n\nIn the next lesson, we'll meet the ternary operator, a one-line expression form of `if`/`else` that's useful when you need to pick between two values inside a larger expression.","pageType":"cpp"}

If-Else Statements

Get Premium