What are the differences between C++20 concepts and SFINAE?

What are the main differences between C++20 concepts and SFINAE?

C++20 concepts provide a way to specify template requirements more clearly, while SFINAE (Substitution Failure Is Not An Error) allows for more flexible template specialization. Concepts are more readable and easier to use, whereas SFINAE can lead to complex code.

Can you give an example of how to use concepts?

Sure! Here's a simple example:

template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
};

template<Addable T>
T add(T a, T b) {
    return a + b;
}

This defines a concept Addable that checks if two objects of type T can be added together.

How does SFINAE work in practice?

In SFINAE, if a substitution in a template fails, it doesn't cause a compilation error. Instead, the compiler simply ignores that particular specialization. For example:

template<typename T, typename = void>
struct MyStruct;

template<typename T>
struct MyStruct<T, std::void_t<decltype(std::declval<T>().foo())>> {
    // Specialization for types with a foo() method
};

Here, if T doesn't have a foo() method, the first template is ignored.

Which one is preferred in modern C++?

In modern C++, concepts are generally preferred due to their clarity and expressiveness. They make the code easier to read and understand, which is especially beneficial in large codebases.