Why Modern C++ Templates Are Getting Simpler: From SFINAE to Concepts

1. SFINAE and std::enable_if (C++11/14)

What is SFINAE?

SFINAE (Substitution Failure Is Not An Error) is a core rule of C++ templates: if substituting template arguments fails, the compiler silently discards that candidate instead of issuing a hard error.

template<typename T>
auto foo(T x) -> typename std::enable_if<std::is_integral<T>::value, void>::type {
    std::cout << "Called for integral type: " << x << std::endl;
}

std::enable_if<condition, ReturnType>

: if condition is false, the function is removed from overload resolution.

Provides a way to constrain templates based on type traits.

Drawback: syntax is verbose and error messages can be hard to read.

Common SFINAE uses

Beyond enable_if, SFINAE is frequently used to detect the presence of member functions or to select overloads based on return‑type or parameter‑type matching.

template<typename T, typename = void>
struct has_serialize : std::false_type {};

template<typename T>
struct has_serialize<T, std::void_t<decltype(std::declval<T>().serialize())>> : std::true_type {};

Detects whether T provides a serialize() member.

Can be used to enable/disable functions based on such detection.

2. constexpr if (C++17)

C++17 introduced constexpr if, allowing compile‑time conditional branches to be expressed directly inside function bodies.

template<typename T>
void process(T x) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "Integral: " << x << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "Floating: " << x << std::endl;
    } else {
        static_assert(false, "Unsupported type!");
    }
}

Advantages: clearer code, eliminates nested enable_if constructs.

Limitations: still relies on type traits; constraint logic is not as declarative as concepts.

3. Concepts (C++20)

Predefined concepts

Concepts provide a dedicated syntax for expressing template constraints.

template<std::integral T>
void foo(T x) {
    std::cout << "Called for integral type: " << x << std::endl;
}

std::integral

is a standard library concept equivalent to std::is_integral but more concise.

Compilers emit friendlier diagnostics when the constraint is not satisfied.

Custom concepts

Users can define their own concepts to require specific operations.

template<typename T>
concept Serializable = requires(T x) {
    { x.serialize() } -> std::convertible_to<std::string>;
};

template<Serializable T>
void save_to_file(T obj) {
    std::string data = obj.serialize();
    // ... further processing ...
}

The requires clause lists the expressions a type must support.

Constraints are expressed directly in the template parameter list, improving readability.

Advantages of concepts

Clearer syntax – no need for enable_if or complex SFINAE tricks.

Better error messages – the compiler indicates exactly which concept is violated.

Stronger expressive power – can require support for specific operators (e.g., +, <<) or arbitrary expressions.

4. Choosing the right technique

SFINAE (C++11/14): works on all compilers, but readability is low.

constexpr if (C++17): simplifies conditional compilation, readability improves, requires C++17 support.

Concepts (C++20): provides the clearest syntax and best diagnostics, but requires a C++20 compiler.

For new projects, prefer concepts for clean, maintainable code. For legacy codebases, gradually replace enable_if with constexpr if where possible, and adopt concepts when the compiler version permits.