> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C++ If with Initializer
The C++17 `if` statement with an initializer permits the execution of an initialization statement immediately before the evaluation of the conditional expression. This construct tightly binds the lifecycle of the initialized variables to the lexical scope of the `if` statement and its associated `else` clauses, preventing namespace pollution.
## Syntax
```cpp theme={"dark"}
if (init-statement condition) {
// true-block
} else {
// false-block
}
```
## Mechanics and Evaluation Order
1. **`init-statement`**: Executed first. This must be either an `expression-statement` or a `simple-declaration`. Because both of these grammar constructs inherently terminate with a semicolon, the semicolon is formally part of the `init-statement` itself, not a separator defined by the `if` statement's grammar.
2. **`condition`**: Evaluated immediately after the `init-statement`. The `condition` can be either:
* An expression that is contextually convertible to `bool`.
* A declaration of a single non-array variable with a brace-or-equal-initializer (e.g., `int y = get_value()`). In this case, the value of the declared variable is contextually converted to `bool`.
If the `condition` evaluates to `true`, the true-block executes; otherwise, the false-block executes.
## Scope and Lifetime Rules
Variables declared within the `init-statement` have a strictly defined lexical scope. The variable is visible and accessible in:
* The `condition`.
* The true-block.
* The false-block (the `else` clause).
* Any subsequent `else if` conditions and their respective blocks.
**Declarative Region Constraints:** The C++ standard dictates that names declared in the `init-statement` and the `condition` share the *same* declarative region. Consequently, a variable declared in the `condition` cannot shadow a variable declared in the `init-statement`. Attempting to do so results in a redeclaration error:
```cpp theme={"dark"}
// INVALID: Redeclaration error. 'x' in the condition cannot shadow 'x' in the init-statement.
if (int x = 1; int x = 2) { }
```
The variables are automatically destroyed when the execution of the entire `if`/`else if`/`else` chain terminates.
## Code Visualization
```cpp theme={"dark"}
if (int status = get_status(); status == 0) {
// 'status' is in scope.
// Executes if status is 0.
} else if (status == 1) {
// 'status' remains in scope for subsequent else-if blocks.
// Executes if status is 1.
} else {
// 'status' remains in scope for the final else block.
// Executes if status is neither 0 nor 1.
}
// 'status' is now out of scope. Its destructor (if applicable) has been called.
```
## Condition as a Declaration
The `condition` itself can also be a declaration, working in tandem with the `init-statement`:
```cpp theme={"dark"}
if (int x = 0; int y = get_value()) {
// Both 'x' and 'y' are in scope.
// Executes if 'y' evaluates to true (non-zero).
}
```
## Structured Binding Integration
The `init-statement` fully supports C++17 structured bindings, allowing the unpacking of tuples, pairs, or structs directly into the conditional scope:
```cpp theme={"dark"}
if (auto [x, y] = get_coordinates(); x > y) {
// Both 'x' and 'y' are in scope and initialized.
}
```
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
