enable_if to Add a function parameter that has a default argument?

Question

I can't understand the second scenario presented here. It says:

•Scenario 2: Adding a function parameter that has a default argument:

template <your_stuff> your_return_type_if_present
yourfunction(args, enable_if_t<your condition, FOO> = BAR) {
    // ...
}

Scenario 2 leaves the parameter unnamed. You could say ::type Dummy = BAR, but the name Dummy is irrelevant, and giving it a name is likely to trigger an unreferenced parameter warning. You have to choose a FOO function parameter type and BAR default argument. You could say int and 0, but then users of your code could accidentally pass to the function an extra integer that would be ignored. Instead, we recommend that you use void ** and either 0 or nullptr because almost nothing is convertible to void **:

template <your_stuff> your_return_type_if_present 
yourfunction(args, typename enable_if<your_condition, void **>::type=nullptr) {
 // ...
}

If scenario 2 leaves the parameter unnamed then in what can it be used? Is there a way to make a code like this work with enable_if?

enum otype {oadd,omull};
template<otype o>
int add(int num1, std::enable_if<o == oadd, int>::type int= num2)
{
    if (o == omull) return num1 * num1;
    if (o == oadd ) return num1 + num2;
 }

Answer 1

Microsoft's documentation there there is as clear as mud. Use this instead.

Providing a function template with an unnamed default parameter of the form:

typename enable_if<your_condition, void **>::type = nullptr

(as the MS scribe suggests), is useful in case - and only in case - you wish to write multiple overloads of the function template with different behaviours that are controlled by one or more of the template arguments. Then, by replacing your_condition with a condition expressing an appropriate requirement on the template argument(s), you can enlist the SFINAE principle to select the specific overload that you want to be instantiated for given template arguments.

The SFINAE parameter - let's call it that - is unused by the instantiated function; it exists solely to provoke SFINAE in function template overload resolution. Hence it can be nameless, and hence it must be defaulted: it must not force you to provide an additional, useless, argument when you invoke the function template.

For example:

#include <type_traits>
#include <iostream>

template <typename T>
T foo(T && t, 
    typename std::enable_if<std::is_same<T,int>::value, void **>::type = nullptr)
{
    std::cout << "Doubling " << t << " gives " << (t + t) << std::endl;
    return t + t; 
}

template <typename T>
T foo(T && t, 
    typename std::enable_if<!std::is_same<T,int>::value, void **>::type = nullptr)
{
    std::cout << "Squaring " << t << " gives " << (t * t) << std::endl;
    return t * t; 
}

using namespace std;

int main()
{
    cout << foo(2) << endl;
    cout << foo(3.3) << endl;
    return 0;
}

Output is:

Doubling 2 gives 4
4
Squaring 3.3 gives 10.89
10.89

In these two overloads of function template foo, the first one doubles it's type T argument and the second one squares its argument, and a SFINAE parameter is used to determine that the doubling overload will be instantiated if T is int and that the squaring overload will be chosen otherwise.

When T is int, the condition:

!std::is_same<T,int>::value

that controls the SFINAE parameter of the squaring overload is false. Consequently the type specifier:

typename std::enable_if<!std::is_same<T,int>::value, void **>::type = nullptr

fails to compile. That is a substitution failure in template resolution. Substituting int for T in the squaring overload is not viable. So the squaring overload is eliminated from the running, and only the doubling overload is left to instantiate the function call.

When T is (say) double and not int, then exactly the opposite happens and only the squaring overload survives template resolution. Call foo(2) and you get doubling. Call foo(3.3) and you get squaring.

MS's specimen SFINAE parameter here is needlessly lengthy.

template< bool B, class T = void >
struct enable_if;

as per C++11 Standard and later, defaults T to void. So the like of:

typename std::enable_if<some_condition, void **>::type = nullptr

can as well be abbreviated to:

typename std::enable_if<some_condition>::type * = nullptr

And as of C++14 the Standard has:

template< bool B, class T = void >
using enable_if_t = typename enable_if<B,T>::type

So the same SFINAE parameter can be further shortened to:

std::enable_if_t<some_condition> * = nullptr

Applying a SFINAE function template parameter to the case that you have gestured at in your post, you would write the like of:

enum ops {
    add,
    multiply
};

template<ops Op>
int op(int const & lhs, int const & rhs, 
        std::enable_if_t<Op == add> * = nullptr)
{
    return lhs + rhs;
}

template<ops Op>
int op(int const & lhs, int const & rhs, 
        std::enable_if_t<Op == multiply> * = nullptr)
{
    return lhs * rhs;
}

...

auto i = op<add>(2,3);
auto j = op<multiply>(2,3);

...
// C++14

Answer 2

enable_if examples (if it helps):

For functions with non-void return type:

For single condition:

template <template T, typename std::enable_if<!std::is_same<T,std::string>::value>::type* = nullptr >
T func(T x){}

For multiple condition:

template <template T, typename std::enable_if<!std::is_same<T,std::string>::value &&!std::is_same<T,int>::value>::type* = nullptr >
T func(T x){}

---

For functions with void return type:

For single condition:

template <template T>
typename std::enable_if<!std::is_same<T,std::string>::value>::type
func(T x){}

For multiple condition:

template <template T>
typename std::enable_if<!std::is_same<T,std::string>::value &&!std::is_same<T,int>::value>::type
func(T x){}

Don't forget to include #include <type_traits>