What are the differences between SFINAE and static_assert?

What are the differences between SFINAE and static_assert in C++?

SFINAE (Substitution Failure Is Not An Error) allows function templates to be excluded from overload resolution based on type traits, while static_assert checks conditions at compile time and generates a compilation error if the condition is false.

Can you give an example of how SFINAE is used?

Sure! Here's a simple example: you can use SFINAE to enable a function only if a type is integral. For instance:

template<typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
void func(T t) {
    // function implementation
}

And how would static_assert be used in a similar context?

With static_assert, you can enforce a condition at compile time. For example:

template<typename T>
void func(T t) {
    static_assert(std::is_integral<T>::value, "T must be an integral type");
    // function implementation
}

So, SFINAE is more flexible than static_assert?

Exactly! SFINAE allows for more complex template specialization, while static_assert is a straightforward way to enforce constraints.