What is the advantage of std::enable_if over static_assert for class templates?

Example of how to overload classes using SFINAE:

#include <type_traits>
#include <iostream>

template <typename, typename = void>
struct Foo;

template <typename Bar>
struct Foo <Bar, typename std::enable_if<std::is_same<Bar,int>::value>::type>
{
    Foo ()
    {
        std::cout << "Hello ";
    }
};

template <typename Bar>
struct Foo <Bar, typename std::enable_if<std::is_same<Bar,bool>::value>::type>
{
    Foo ()
    {
        std::cout << "world!n";
    }
};

int main()
{
    Foo<int>();
    Foo<bool>();
}

For cases where you don't want to do overloading but still want to restrict to a set of types, I agree that:

template <typename Bar>
class Foo
{
    static_assert(
        std::is_same<Bar,int>::value || 
        std::is_same<Bar,bool>::value, 
        "Bar must be bool or int");
    
    // class stuff
};

...is clearer and simpler than:

template <typename Bar,
    typename std::enable_if<
    std::is_same<Bar,int>::value ||
    std::is_same<Bar,bool>::value,
    bool>::type = true>
class Foo
{
    // class stuff
};

...especially because with the second option the compiler refers to Foo objects with their first argument and their second argument (true, in our case), which can be mysterious to the user. Also, it's more messy if you want a header to handle the class with only a light-weight declaration of it (see how to do that here).