Skip to content

Init Statements and if constexpr — C++17 if/switch with Initializer, Compile-Time Conditionals

DodaTech Updated 2026-06-28 9 min read

In this tutorial, you will learn about Init Statements and if constexpr. We cover key concepts, practical examples, and best practices to help you master this topic.

C++17 if/switch init statements let you declare a variable and immediately use it in the condition, scoping it to the block, while if constexpr selects branches at compile time based on type properties.

What You'll Learn

You will use if (auto x = expr; condition) to scope variables to conditional blocks, write switch (auto x = expr; x) for scoped switch variables, apply if constexpr for compile-time template branching, understand that discarded if constexpr branches are not instantiated, and combine init statements with if constexpr for clean, scoped template code.

Why It Matters

Init statements reduce variable scope — a variable needed only for a condition no longer leaks into the enclosing scope. if constexpr eliminates SFINAE for most type-dependent function bodies. Together, they make C++ code safer and more readable, especially in template and generic programming contexts.

Learning Path

graph LR
    A["54: Structured Bindings"] --> B["55: if/switch init + if constexpr"]
    B --> C["56: Fold Expressions"]
    C --> D["57: Coroutines"]
    style A fill:#4a90d9,stroke:#2c5f8a,color:#fff
    style B fill:#4a90d9,stroke:#2c5f8a,color:#fff
    style C fill:#4a90d9,stroke:#2c5f8a,color:#fff
    style D fill:#4a90d9,stroke:#2c5f8a,color:#fff

if with Initializer

The init statement declares a variable that lives for the duration of the if (and optional else) block.

#include <iostream>
#include <map>
#include <string>

int main() {
    std::map<std::string, int> scores = {
        {"Alice", 95},
        {"Bob", 87}
    };

    // Before C++17: iterator leaked into outer scope
    auto it = scores.find("Alice");
    if (it != scores.end()) {
        std::cout << "Found: " << it->second << "\n";
    }
    // 'it' is still in scope here (polluting namespace)

    // C++17: init statement scopes the iterator
    if (auto it = scores.find("Bob"); it != scores.end()) {
        std::cout << "Found: " << it->second << "\n";
    }
    // 'it' is out of scope here — cleaner

    // With else clause
    if (auto it = scores.find("Charlie"); it != scores.end()) {
        std::cout << "Found: " << it->second << "\n";
    } else {
        // 'it' is available here too
        std::cout << "Charlie not found\n";
    }
    // 'it' is out of scope
}

switch with Initializer

Same pattern for switch statements.

#include <iostream>
#include <string>

enum class Status { OK, Warning, Error };

Status getStatus() { return Status::Warning; }

int main() {
    // Before C++17
    Status s = getStatus();
    switch (s) {
        case Status::OK:      std::cout << "All good\n"; break;
        case Status::Warning: std::cout << "Warning\n"; break;
        case Status::Error:   std::cout << "Error\n"; break;
    }

    // C++17: scoped switch variable
    switch (auto status = getStatus(); status) {
        case Status::OK:      std::cout << "All good\n"; break;
        case Status::Warning: std::cout << "Warning\n"; break;
        case Status::Error:   std::cout << "Error\n"; break;
    }
    // 'status' is out of scope here

    // Practical example: read from file descriptor
    // switch (int fd = open("file.txt", O_RDONLY); fd) {
    //     case -1: perror("open failed"); break;
    //     default: /* use fd */ close(fd); break;
    // }
}

if constexpr Basics

if constexpr evaluates the condition at compile time and discards the non-selected branch entirely.

#include <iostream>
#include <type_traits>
#include <string>

template <typename T>
auto describe(const T& value) {
    if constexpr (std::is_integral_v<T>) {
        return "integer: " + std::to_string(value);
    } else if constexpr (std::is_floating_point_v<T>) {
        return "float: " + std::to_string(value);
    } else if constexpr (std::is_same_v<T, std::string>) {
        return "string: " + value;
    } else {
        return "unknown type";
    }
}

int main() {
    std::cout << describe(42) << "\n";         // integer: 42
    std::cout << describe(3.14) << "\n";       // float: 3.140000
    std::cout << describe("hello") << "\n";    // unknown type (const char*)
    std::cout << describe(std::string("hi")) << "\n"; // string: hi
}

The key property: the discarded branch is not instantiated. Invalid code in a discarded branch will not cause compilation errors.

Discarded Branches Are Not Instantiated

This is the critical difference from runtime if.

#include <iostream>
#include <type_traits>

template <typename T>
void process(T& value) {
    // Runtime if: both branches must compile for all T
    // if (std::is_integral_v<T>) {
    //     value += 1;     // Works for int
    // } else {
    //     value.push_back(1);  // Error for int: no push_back
    // }

    // if constexpr: only the selected branch is compiled
    if constexpr (std::is_integral_v<T>) {
        value += 1;          // Only compiled when T is integral
        std::cout << "Incremented to " << value << "\n";
    } else if constexpr (std::is_same_v<T, std::vector<int>>) {
        value.push_back(1);  // Only compiled when T is vector
        std::cout << "Pushed back, size=" << value.size() << "\n";
    }
}

int main() {
    int x = 5;
    process(x);          // Incremented to 6

    std::vector<int> v;
    process(v);          // Pushed back, size=1
}

if constexpr with auto Parameters (C++17)

Combine with generic lambdas or abbreviated templates.

#include <iostream>
#include <type_traits>

int main() {
    // Generic lambda with if constexpr
    auto printer = [](const auto& value) {
        if constexpr (std::is_integral_v<decltype(value)>) {
            std::cout << "Int: " << value << "\n";
        } else if constexpr (std::is_floating_point_v<decltype(value)>) {
            std::cout << "Float: " << value << "\n";
        } else {
            std::cout << "Other: " << value << "\n";
        }
    };

    printer(42);         // Int: 42
    printer(3.14);       // Float: 3.14
    printer("hello");    // Other: hello

    // In abbreviated function templates (C++20)
    auto classify = [](std::integral auto val) {
        std::cout << "Integral: " << val << "\n";
    };
    classify(100);       // Integral: 100
}

if constexpr with Return Type Deduction

Different branches can return different types if they are compatible.

#include <iostream>
#include <type_traits>
#include <string>

// Returns different types, but all branches must be consistent
// for the caller
template <typename T>
auto convert(const T& value) {
    if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);  // Returns std::string
    } else {
        return value;                   // Returns T (must be string-convertible)
    }
}

int main() {
    auto s1 = convert(42);           // std::string "42"
    auto s2 = convert(3.14);         // std::string "3.14"
    auto s3 = convert(std::string("hello"));  // std::string "hello"

    std::cout << s1 << " " << s2 << " " << s3 << "\n";
    // 42 3.140000 hello
}

Note: All branches of if constexpr in a function with auto return type must return the same type or the return type must be deduced consistently. Mismatched types cause compilation errors.

Combining Init Statement with if constexpr

You can nest init statements inside if constexpr blocks.

#include <iostream>
#include <type_traits>
#include <vector>

template <typename Container>
void processContainer(Container& c) {
    if constexpr (std::is_same_v<Container, std::vector<int>>) {
        if (auto size = c.size(); size > 0) {
            std::cout << "Processing vector with " << size << " elements\n";
            for (auto& elem : c) elem *= 2;
        }
    } else {
        std::cout << "Non-vector container, size=" << c.size() << "\n";
    }
}

int main() {
    std::vector<int> v = {1, 2, 3};
    processContainer(v);           // Processing vector with 3 elements
    for (int x : v) std::cout << x << " ";  // 2 4 6

    std::list<int> lst = {10, 20};
    processContainer(lst);         // Non-vector container, size=2
}

Real-World: Scoped Lock with Init

A practical use case for init statements.

#include <iostream>
#include <mutex>
#include <map>
#include <string>

class ThreadSafeCache {
    std::mutex mutex_;
    std::map<std::string, int> cache_;
public:
    int get(const std::string& key, int defaultVal) {
        // Lock is scoped to the if block
        if (std::lock_guard lock(mutex_); cache_.count(key)) {
            return cache_[key];
        }
        return defaultVal;
    }

    void set(const std::string& key, int value) {
        std::lock_guard lock(mutex_);
        cache_[key] = value;
    }
};

int main() {
    ThreadSafeCache cache;
    cache.set("count", 42);

    // The lock is acquired and released within the if statement
    if (int val = cache.get("count", 0); val > 0) {
        std::cout << "Count: " << val << "\n";  // Count: 42
    }

    if (int val = cache.get("missing", -1); val > 0) {
        std::cout << "Found\n";
    } else {
        std::cout << "Not found, default: " << val << "\n";  // Not found, default: -1
    }
}

Common Mistakes

Mistake 1: Thinking if constexpr works with runtime values

int x = std::rand() % 10;
if constexpr (x > 5) { ... }  // Error: x is not a constant expression

if constexpr requires a compile-time constant expression.

Mistake 2: Forgetting that both branches must be syntactically valid

template <typename T>
void func(T value) {
    if constexpr (false) {
        value.invalidMember();  // Not instantiated, no error here
    }
}
void g() {
    func(42);  // OK: the invalid branch is never instantiated
}

Syntax must be valid, but semantic errors in discarded branches are fine.

Mistake 3: Using if constexpr in non-template functions

void func(int x) {
    if constexpr (x > 5) { ... }  // Error: x is not a constant
}

Works only in template contexts or with truly constant expressions.

Mistake 4: Shadowing the init variable in the condition

if (auto x = foo(); x) {
    auto x = bar();  // Shadows the init variable
}

Avoid reusing the same variable name inside the block.

Mistake 5: Forgetting semicolon in init statement

if (auto x = getValue() condition)  // Missing semicolon!

The syntax is if (init; condition) — the semicolon is required.

Practice Questions

  1. What is the output?
int x = 10;
if (int y = x + 5; y > 10) {
    std::cout << y;
}

Answer: 15 — y is initialized to 15, then checked (15 > 10).

  1. What is the key difference between if and if constexpr? Answer: if constexpr evaluates at compile time and discards the non-selected branch entirely (no instantiation). if evaluates at runtime and both branches must compile.

  2. Can if constexpr be used outside templates? Answer: Yes, but only with compile-time constant expressions (e.g., if constexpr (sizeof(int) > 2)).

  3. Write a function using if constexpr that works for both int and vector.

template <typename T>
void doubleIt(T& value) {
    if constexpr (std::is_integral_v<T>) value *= 2;
    else for (auto& v : value) v *= 2;
}
  1. What is the scope of a variable declared in an init statement? Answer: The variable is scoped to the if/switch block and its optional else clause. It is destroyed when control leaves the statement.

FAQ

What are init statements in C++17

Init statements let you declare a variable within an if or switch condition. The variable is scoped to the conditional block and its optional else clause.

What does if constexpr do

if constexpr evaluates a compile-time condition and discards the non-selected branch. The discarded branch is not instantiated, preventing compilation errors for invalid code in that branch.

Can I use init statements with while loops

No, init statements are only for if and switch. Range-for has its own init statement in C++20.

Does if constexpr replace SFINAE

For function bodies, yes. For function signatures (overload resolution), concepts are the modern replacement. if constexpr works inside functions.

Are init statements more efficient

No performance difference — they are purely scoping improvements. The compiler generates identical code.

Mini Project

Build a type-safe toNumber function using if constexpr that converts various types to double:

#include <iostream>
#include <string>
#include <type_traits>

// Your toNumber function

int main() {
    std::cout << toNumber(42) << "\n";               // 42.0 (int)
    std::cout << toNumber(3.14f) << "\n";            // 3.14 (float)
    std::cout << toNumber("3.14159") << "\n";        // 3.14159 (string literal)
    std::cout << toNumber(std::string("2.718")) << "\n"; // 2.718 (std::string)
    std::cout << toNumber(true) << "\n";             // 1.0 (bool)
    // toNumber(std::vector<int>{});  // Would fail: no valid conversion
}

This project demonstrates how C++ if constexpr enables writing generic functions that handle multiple types with clean, readable code — a pattern used throughout modern C++ libraries.

What's Next

You now use init statements and if constexpr for scoped and compile-time conditionals. Next, you will revisit fold expressions (C++17) — a concise syntax for applying operators to parameter packs without Recursion.

← Previous Structured Bindings C++17 — Decomposing Tuples, Pairs, Arrays, and Structs with auto Next → Fold Expressions (C++17) — Unary and Binary Folds, Operator Packs, Compile-Time Reduction

Built by the developers of DodaTech

Doda Browser, DodaZIP & Durga Antivirus Pro

Home Browse Cpp