8.4 — Constexpr if statements

In this lesson, you'll learn about constexpr if statements (also known as "if constexpr"), a powerful C++17 feature that allows conditional compilation based on compile-time constants.

What is constexpr if?

Constexpr if is a special form of if statement that is evaluated at compile time rather than runtime. If the condition is false, the entire if block is discarded during compilation and doesn't appear in the final executable.

if constexpr (condition)
{
    // This code only exists in the executable if condition is true at compile time
}

The condition must be a constant expression that can be evaluated at compile time.

Why use constexpr if?

Constexpr if is particularly useful for:

1. Template programming - Making templates more flexible
2. Performance optimization - Eliminating code paths at compile time
3. Conditional compilation - Including code only when needed
4. Type-based logic - Different behavior for different types

Basic constexpr if examples

Example 1: Compile-time configuration

#include <iostream>

int main()
{
    constexpr bool DEBUG_MODE = true;
    
    if constexpr (DEBUG_MODE)
    {
        std::cout << "Debug: Starting program\n";
    }
    
    std::cout << "Hello, World!\n";
    
    if constexpr (DEBUG_MODE)
    {
        std::cout << "Debug: Program finished\n";
    }
    
    return 0;
}

Output (when DEBUG_MODE is true):

Debug: Starting program
Hello, World!
Debug: Program finished

If we set DEBUG_MODE to false, the debug statements are completely removed from the compiled program.

Example 2: Platform-specific code

#include <iostream>

int main()
{
    constexpr bool IS_WINDOWS = false;
    constexpr bool IS_LINUX = true;
    
    std::cout << "Running on: ";
    
    if constexpr (IS_WINDOWS)
    {
        std::cout << "Windows\n";
        // Windows-specific code would go here
    }
    else if constexpr (IS_LINUX)
    {
        std::cout << "Linux\n";
        // Linux-specific code would go here
    }
    else
    {
        std::cout << "Unknown platform\n";
    }
    
    return 0;
}

Output:

Running on: Linux

Constexpr if vs regular if

Regular if (runtime evaluation)

#include <iostream>

int main()
{
    const bool condition = true;
    
    if (condition)  // Regular if - evaluated at runtime
    {
        std::cout << "This code exists in the executable\n";
    }
    else
    {
        std::cout << "This code ALSO exists in the executable\n";
    }
    
    return 0;
}

With regular if, both branches exist in the compiled program, even though only one executes.

Constexpr if (compile-time evaluation)

#include <iostream>

int main()
{
    constexpr bool condition = true;
    
    if constexpr (condition)  // Constexpr if - evaluated at compile time
    {
        std::cout << "This code exists in the executable\n";
    }
    else
    {
        std::cout << "This code does NOT exist in the executable\n";
    }
    
    return 0;
}

With constexpr if, only the taken branch exists in the compiled program.

Using constexpr if with templates

Constexpr if is most powerful when used with templates, allowing different behavior for different types.

Example: Generic function with type-specific behavior

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

template<typename T>
void printValue(T value)
{
    if constexpr (std::is_same_v<T, std::string>)
    {
        std::cout << "String: \"" << value << "\"\n";
    }
    else if constexpr (std::is_integral_v<T>)
    {
        std::cout << "Integer: " << value << "\n";
    }
    else if constexpr (std::is_floating_point_v<T>)
    {
        std::cout << "Float: " << value << "\n";
    }
    else
    {
        std::cout << "Unknown type\n";
    }
}

int main()
{
    printValue(42);           // Calls integer version
    printValue(3.14);         // Calls float version
    printValue(std::string("Hello"));  // Calls string version
    
    return 0;
}

Output:

Integer: 42
Float: 3.14
String: "Hello"

Example: Optimized container operations

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

template<typename Container>
void advanceIterator(Container& container, typename Container::iterator& it, int n)
{
    if constexpr (std::is_same_v<Container, std::vector<typename Container::value_type>>)
    {
        // Vectors support random access - use fast advancement
        std::cout << "Using fast random access advancement\n";
        it += n;
    }
    else
    {
        // Other containers might only support sequential access
        std::cout << "Using sequential advancement\n";
        for (int i = 0; i < n; ++i)
        {
            ++it;
        }
    }
}

int main()
{
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto vec_it = vec.begin();
    
    std::list<int> lst = {1, 2, 3, 4, 5};
    auto list_it = lst.begin();
    
    advanceIterator(vec, vec_it, 3);   // Uses fast method
    advanceIterator(lst, list_it, 3);  // Uses sequential method
    
    return 0;
}

Output:

Using fast random access advancement
Using sequential advancement

Constexpr variables and expressions

Constexpr variables

#include <iostream>

constexpr int MAX_SIZE = 100;
constexpr double PI = 3.14159;
constexpr bool ENABLE_LOGGING = false;

int main()
{
    if constexpr (MAX_SIZE > 50)
    {
        std::cout << "Large array mode\n";
    }
    
    if constexpr (ENABLE_LOGGING)
    {
        std::cout << "Logging enabled\n";  // This won't appear in output
    }
    
    return 0;
}

Constexpr functions

#include <iostream>

constexpr int factorial(int n)
{
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

constexpr bool isPowerOfTwo(int n)
{
    return n > 0 && (n & (n - 1)) == 0;
}

int main()
{
    constexpr int fact5 = factorial(5);  // Computed at compile time
    
    if constexpr (fact5 == 120)
    {
        std::cout << "5! = 120 (verified at compile time)\n";
    }
    
    if constexpr (isPowerOfTwo(8))
    {
        std::cout << "8 is a power of 2\n";
    }
    
    if constexpr (isPowerOfTwo(10))
    {
        std::cout << "10 is a power of 2\n";  // This won't appear
    }
    else
    {
        std::cout << "10 is not a power of 2\n";
    }
    
    return 0;
}

Output:

5! = 120 (verified at compile time)
8 is a power of 2
10 is not a power of 2

Practical applications

Example 1: Debug vs Release builds

#include <iostream>
#include <chrono>

constexpr bool DEBUG_BUILD = 
#ifdef DEBUG
    true;
#else
    false;
#endif

template<typename Func>
void measureTime(Func func, const char* name)
{
    if constexpr (DEBUG_BUILD)
    {
        auto start = std::chrono::high_resolution_clock::now();
        func();
        auto end = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
        std::cout << name << " took " << duration.count() << " microseconds\n";
    }
    else
    {
        func();  // Just run the function without timing
    }
}

void expensiveOperation()
{
    // Simulate some work
    for (int i = 0; i < 1000000; ++i)
    {
        // Do something
    }
}

int main()
{
    measureTime(expensiveOperation, "expensiveOperation");
    return 0;
}

Example 2: Feature flags

#include <iostream>

constexpr bool FEATURE_NEW_ALGORITHM = true;
constexpr bool FEATURE_ENHANCED_UI = false;
constexpr bool FEATURE_ANALYTICS = true;

void processData()
{
    if constexpr (FEATURE_NEW_ALGORITHM)
    {
        std::cout << "Using new optimized algorithm\n";
        // New algorithm code here
    }
    else
    {
        std::cout << "Using legacy algorithm\n";
        // Old algorithm code here
    }
}

void updateUI()
{
    if constexpr (FEATURE_ENHANCED_UI)
    {
        std::cout << "Rendering enhanced UI\n";
        // Enhanced UI code here
    }
    else
    {
        std::cout << "Rendering standard UI\n";
        // Standard UI code here
    }
}

void trackEvent(const char* event)
{
    if constexpr (FEATURE_ANALYTICS)
    {
        std::cout << "Tracking event: " << event << "\n";
        // Analytics code here
    }
    // If analytics is disabled, this function does nothing
}

int main()
{
    processData();
    updateUI();
    trackEvent("user_login");
    
    return 0;
}

Output:

Using new optimized algorithm
Rendering standard UI
Tracking event: user_login

Nested constexpr if

You can nest constexpr if statements:

#include <iostream>
#include <type_traits>

template<typename T>
void analyzeType()
{
    std::cout << "Analyzing type...\n";
    
    if constexpr (std::is_arithmetic_v<T>)
    {
        std::cout << "Type is arithmetic\n";
        
        if constexpr (std::is_integral_v<T>)
        {
            std::cout << "Type is an integer\n";
            
            if constexpr (std::is_signed_v<T>)
            {
                std::cout << "Type is signed\n";
            }
            else
            {
                std::cout << "Type is unsigned\n";
            }
        }
        else
        {
            std::cout << "Type is floating-point\n";
        }
    }
    else
    {
        std::cout << "Type is not arithmetic\n";
    }
    
    std::cout << "---\n";
}

int main()
{
    analyzeType<int>();
    analyzeType<unsigned int>();
    analyzeType<double>();
    analyzeType<std::string>();
    
    return 0;
}

Output:

Analyzing type...
Type is arithmetic
Type is an integer
Type is signed
---
Analyzing type...
Type is arithmetic
Type is an integer
Type is unsigned
---
Analyzing type...
Type is arithmetic
Type is floating-point
---
Analyzing type...
Type is not arithmetic
---

Limitations and considerations

1. C++17 requirement

Constexpr if is only available in C++17 and later. Make sure your compiler supports it:

g++ -std=c++17 program.cpp

2. Condition must be constexpr

The condition must be evaluable at compile time:

// This works
constexpr bool condition = true;
if constexpr (condition) { }

// This doesn't work
bool condition = true;  // Not constexpr
if constexpr (condition) { }  // Error!

3. Template instantiation

In templates, even discarded branches must be syntactically valid:

template<typename T>
void func()
{
    if constexpr (std::is_integral_v<T>)
    {
        T value = 42;  // This must be syntactically valid even if not used
        // ...
    }
}

Best practices

1. Use for performance-critical code

template<bool OptimizeForSpeed>
void sort(std::vector<int>& data)
{
    if constexpr (OptimizeForSpeed)
    {
        // Use faster but more memory-intensive algorithm
        std::sort(data.begin(), data.end());
    }
    else
    {
        // Use slower but memory-efficient algorithm
        std::stable_sort(data.begin(), data.end());
    }
}

2. Combine with type traits

#include <type_traits>

template<typename T>
void process(T& container)
{
    if constexpr (std::is_same_v<T, std::vector<typename T::value_type>>)
    {
        // Vector-specific optimizations
        container.reserve(container.size() * 2);
    }
    
    // Common processing for all containers
    for (auto& item : container)
    {
        // Process item
    }
}

3. Use for conditional debugging

#ifndef NDEBUG
constexpr bool DEBUG = true;
#else
constexpr bool DEBUG = false;
#endif

template<typename T>
void debugPrint(const T& value)
{
    if constexpr (DEBUG)
    {
        std::cout << "Debug: " << value << "\n";
    }
}

Summary

Constexpr if statements provide compile-time conditional compilation:

• Evaluated at compile time: Conditions must be constant expressions
• Code elimination: False branches are completely removed from the executable
• Template-friendly: Particularly useful for generic programming
• Performance benefits: Eliminates runtime overhead of unused code paths
• Feature flags: Enable/disable features at compile time
• Platform-specific code: Include platform-specific code conditionally

Key benefits:

• Smaller executables (unused code is removed)
• Better performance (no runtime evaluation)
• More flexible templates
• Cleaner conditional compilation

Constexpr if is a powerful tool for creating efficient, flexible, and maintainable C++ code, especially when working with templates and generic programming.

Quiz

1. What's the difference between if and if constexpr?
2. When is the condition in a constexpr if statement evaluated?
3. What happens to the false branch in a constexpr if statement?
4. What C++ standard introduced constexpr if?
5. Can you use constexpr if with runtime variables?

Practice exercises

1. Feature flags: Create a program with three constexpr boolean flags that control different features (logging, caching, validation). Show how the executable size changes when features are enabled/disabled.

2. Type-specific function: Write a template function that behaves differently for integers (prints in decimal and hex), floating-point numbers (prints with precision), and strings (prints with quotes).

3. Debug build: Create a constexpr if structure that includes extensive debug output in debug builds but removes it completely in release builds.

4. Container optimizer: Write a template function that uses different algorithms based on whether a container supports random access iterators or not.