SFINAE vs Concepts

C++ concepts, introduced in C++20, provide a more expressive and readable way to constrain templates compared to the traditional SFINAE (Substitution Failure Is Not An Error) technique.

With SFINAE, you would typically use std::enable_if and type traits to conditionally exclude template specializations based on certain type properties. Here's an example:

1#include <type_traits>
2
3template <typename T,
4  typename = std::enable_if_t<
5    std::is_integral_v<T>>>
6void process(T value) {
7  // Process integral types
8}
9
10template <typename T,
11  typename = std::enable_if_t<
12    std::is_floating_point_v<T>>>
13void process(T value) {
14  // Process floating-point types
15}

In this SFINAE approach, the std::enable_if and type traits are used to create separate overloads of the process function for integral and floating-point types.

While SFINAE works, it can lead to complex and hard-to-read code, especially when dealing with multiple constraints.

With concepts, you can express the same constraints in a more readable and expressive manner:

1#include <concepts>
2
3template <std::integral T>
4void process(T value) {
5  // Process integral types
6}
7
8template <std::floating_point T>
9void process(T value) {
10  // Process floating-point types
11}

Here, the std::integral and std::floating_point concepts are used directly to constrain the template parameter T. The resulting code is cleaner and easier to understand.

Concepts also allow you to define your own named constraints, which can encapsulate complex requirements and improve code reusability. For example:

1#include <concepts>
2
3template <typename T>
4concept Addable = requires(T a, T b) {
5  { a + b } -> std::same_as<T>;
6};
7
8template <Addable T>
9T add(T a, T b) {
10  return a + b;
11}

In this case, the Addable concept checks if a type T supports the + operator and returns the same type. The add function can then be constrained using the Addable concept, ensuring that it only accepts types that fulfill the concept's requirements.

Overall, concepts provide a more expressive, readable, and maintainable way to constrain templates compared to SFINAE techniques.