Specializing a template method with enable_if

Question

I'm writing a template class that stores a std::function in order to call it later. Here is the simplifed code:

template <typename T>
struct Test
{
    void call(T type)
    {
        function(type);
    }
    std::function<void(T)> function;
};

The problem is that this template does not compile for the void type because

void call(void type)

becomes undefined.

Specializing it for the void type doesn't alleviate the problem because

template <>
void Test<void>::call(void)
{
    function();
}

is still incompatible with the declaration of call(T Type).

So, using the new features of C++ 11, I tried std::enable_if:

typename std::enable_if_t<std::is_void_v<T>, void> call()
{
    function();
}

typename std::enable_if_t<!std::is_void_v<T>, void> call(T type)
{
    function(type);
}

but it does not compile with Visual Studio:

error C2039: 'type' : is not a member of 'std::enable_if'

How would you tackle this problem?

SFINAE works only for *deduced* template parameters. – Kerrek SB Nov 28 '17 at 00:54 — Kerrek SB, Nov 28 '17 at 00:54

Jarod42 · Answer 1 · 2017-11-28T01:12:41.027

4

Specialize the whole class:

template <>
struct Test<void>
{
    void call()
    {
        function();
    }
    std::function<void()> function;
};

edited Nov 28 '17 at 01:12

answered Nov 28 '17 at 00:54

Jarod42

203,559
14
181
302

Sure it works, but the idea was to precisely avoid specializing the whole class by using recent SFINAE constructs. – Mark Morrisson Nov 28 '17 at 20:46

score 2 · Answer 2 · answered Nov 28 '17 at 01:52

If you don't stick to use void, and your intention is to actually able to use Test without any parameters, then use variadic template:

template <typename ...T>
struct Test
{
    void call(T ...type)
    {
        function(type...);
    }
    std::function<void(T...)> function;
};

This way, you can have any number of parameters. If you want to have no parameters, use this:

Test<> t;
t.call();

So this is not exactly the syntax you wanted, but there is no need for specialization, and this solution is more flexible, because supports any number of parameters.

I gave a simplified version of the code, but actually the idea was to handle a void return type. I handled the input parameters with a variadic template as you suggested. — Mark Morrisson, Nov 28 '17 at 20:46

max66 · Accepted Answer · 2017-11-28T02:03:08.383

SFINAE doesn't work over (only) the template parameters of the class/structs.

Works over template methods whit conditions involving template parameters of the method.

So you have to write

   template <typename U = T>
   std::enable_if_t<std::is_void<U>::value> call()
    { function(); }

   template <typename U = T>
   std::enable_if_t<!std::is_void<U>::value> call(T type)
    { function(type); }

or, if you want to be sure that U is T

   template <typename U = T>
   std::enable_if_t<   std::is_same<U, T>::value
                    && std::is_void<U>::value> call()
    { function(); }

   template <typename U = T>
   std::enable_if_t<std::is_same<U, T>::value
                    && !std::is_void<U>::value> call(T type)
    { function(type); }

p.s.: std::enable_if_t is a type so doesn't require typename before.

p.s.2: you tagged C++11 but your example use std::enable_if_t, that is C++14, and std::is_void_v, that is C++17

I didn't fully understand the subtlety that explains why SFINAE works in your case and not mine, but your code compiles. And thank you for your additional comments. — Mark Morrisson, Nov 28 '17 at 20:45
For production-level code, you probably also want a `std::is_same_v` inside the `enable_if_t` to thwart an explicit `call()` for `U` unequal to `T` from compiling. — TemplateRex, Nov 29 '17 at 13:17

Specializing a template method with enable_if

3 Answers3