Great question! Let's break down your static_ite implementation, verify its correctness, and explore alternative approaches for C++11 since constexpr if isn't available yet.

Correctness Verification #

First, let's walk through what your code does step by step:

• The first two overloads handle branch selection: when passed std::true_type, they return the first argument (T), and when passed std::false_type, they return the second argument (F). Using constexpr here is valid for C++11, as long as arguments are compile-time constants (which they will be given how this function is called).
• The third template acts as the entry point: it uses std::integral_constant<bool, cond> to tag-dispatch to the correct overload. Since cond is a compile-time template parameter, this branch resolution happens entirely at compile time—just like constexpr if.
• You’re using std::forward to preserve the value category (lvalue/rvalue) of input arguments, which is perfect for avoiding unnecessary copies and ensuring correct behavior with move-only types.
• The trailing return type with decltype correctly deduces the return type based on which overload is selected, which works seamlessly in C++11.

Overall, your implementation is correct for its intended use case: a compile-time "if-then-else" that returns one of two values/objects based on a compile-time boolean condition.

Limitations to Note #

While your implementation works well, it’s important to understand its differences from full constexpr if:

• It’s focused on returning values, not executing arbitrary statement blocks. Unlike constexpr if, which lets you write multiple lines of code in each branch, static_ite requires you to encapsulate branch logic into the arguments you pass (e.g., lambda functions or function objects).
• The two branches must produce compatible return types only if the function is used in a context where the return type needs to be uniform. However, since the template is instantiated separately for cond=true and cond=false, you can have different return types for each branch when using it in template code.

If you need more flexibility, here are a few other approaches to consider:

1. Extended Tag Dispatch #

Your code already uses tag dispatch, but you can expand it to handle more complex logic within each branch (instead of just returning the input):

template <typename T>
constexpr T handle_true(T&& t) {
    // Add custom logic for the true branch here
    return std::forward<T>(t);
}

template <typename F>
constexpr F handle_false(F&& f) {
    // Add custom logic for the false branch here
    return std::forward<F>(f);
}

template <bool cond, typename T, typename F>
constexpr auto static_ite(T&& t, F&& f) -> decltype(
    cond ? handle_true(std::forward<T>(t)) : handle_false(std::forward<F>(f))
) {
    return cond ? handle_true(std::forward<T>(t)) : handle_false(std::forward<F>(f));
}

This lets you embed additional compile-time logic directly in the handler functions.

2. SFINAE-Based Branching #

Using std::enable_if, you can create separate functions for each branch, which is useful if you want to handle different logic without passing arguments:

template <bool cond>
typename std::enable_if<cond, int>::type
compute_value() {
    // True branch logic
    return 42;
}

template <bool cond>
typename std::enable_if<!cond, int>::type
compute_value() {
    // False branch logic
    return 100;
}

// Usage:
constexpr int val = compute_value<sizeof(long) == 8>();

This is great for functions that don’t need to take arguments but depend on a compile-time condition.

3. Compile-Time Function Objects #

If you need to encapsulate more complex constexpr logic, define constexpr function objects (since C++11 doesn’t support constexpr lambdas natively):

struct TrueLogic {
    constexpr int operator()(int x) const {
        return x * 2;
    }
};

struct FalseLogic {
    constexpr int operator()(int x) const {
        return x + 10;
    }
};

template <bool cond, typename T, typename F, typename Arg>
constexpr auto apply_logic(Arg&& arg) -> decltype(
    static_ite<cond>(T(), F())(std::forward<Arg>(arg))
) {
    return static_ite<cond>(T(), F())(std::forward<Arg>(arg));
}

// Usage:
constexpr int result = apply_logic<true, TrueLogic, FalseLogic>(5); // Returns 10

Your original static_ite implementation is a solid, correct solution for C11 when you need a compile-time alternative to constexpr if for returning values. For more complex statement-based logic, wrap your branch code into function objects or lambdas (if your compiler supports C14 constexpr lambdas as an extension) and pass them to static_ite.

内容的提问来源于stack exchange，提问作者Saurav Yadav