The parameter is anonymous. The type and default is specified, but there's nothing to actually refer to it later.

template<typename> struct A; // fine
template<int> struct B; // fine
template<typename F, F = nullptr> struct C; // fine
using AI = A<int>;
using BI = B<5>;
using CI = C<int, 5>;
using CD = C<void*>; // all fine
using Oops = C<char>; // not fine

Your case just replaces the simpler types like int and F with a big honking typename std::enable_if<...>::type. We don't care about the actual argument that gets passed it ends up being, so that's why it's unnamed.

template <class T,
         typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
void do_stuff(T &t) {
    std::cout << "do_stuff integraln";
}

Plugging in T = int, typename std::enable_if<std::is_integral<T>::value>::type = void, so the second defaulted parameter just looks like void* = nullptr, which means it's an unnamed parameter of type void* that defaults to nullptr. Note that the typename is part of the type of a non-type template parameter. It is not serving in its other capacity as the introducer of type template parameters. Also, please note that the modern C++ way to write this is

// typename instead of class is more a style thing
template<typename T, std::enable_if_t<std::is_integral_v<T>>* = nullptr>

where enable_if_t and is_integral_v are aliases that abbreviate all the ::value and typename ...::type nonsense:

namespace std {
    template<typename T>
    constexpr inline bool is_integral_v = std::is_integral<T>::value;
    template<bool B, typename T = void>
    using enable_if_t = typename std::enable_if<B, T>::type;
}

There are two kinds of template parameters:

• type template parameters
• non-type template parameters

The name of the template parameter is optional

A template parameter can have a default value

Type template parameter

named, non-defaulted

template <class T>
struct X {};

Usage:

X<int> x{};

named, defaulted

template <class T = int>
struct X {};

Usage:

X<> x1{};
X<char> x2{};

unnamed non-defaulted

template <class>
struct X {};

Usage:

X<int> x{};

unnamed, defaulted

template <class = int>
struct X {};

Usage:

X<> x1{};
X<char> x2{};

Non-type template parameter

named, non-defaulted

template <int I>
struct X {};

Usage:

X<24> x{};

named, defaulted

template <int I = 24>
struct X {};

Usage:

X<> x1{};
X<11> x2{};

unnamed, non-defaulted

template <int>
struct X {};

Usage:

X<11> x{};

unnamed, defaulted

template <int = 24>
struct X {};

Usage:

X<> x1{};
X<11> x2{};

---

For SFINAE the technique requires a default value. Since you don't care for the parameter inside the class you can skip its name. As for the type or non-type you can chose which one is easier to write in your particular case.