Class template: why can't I specialize a single method for void type?

Question

I have a class template:

template <typename Argument> class Signal
{
    void invoke(Argument arg) {}
};

Now I want to invoke signals without parameter (meaning void parameter). I assume I could specialize the whole class for void and it would compile. But there's a lot of code in the class, I don't want to duplicate it. I want to only specialize whatever neccessary. So I try adding:

// void specialization
template<> 
void Signal<void>::invoke()
{

}

And get an error:

error C2244: 'Signal::invoke' : unable to match function definition to an existing declaration

Why is that?

The same code works for any type other than void.

What is "void parameter"? `void*` ok, but `void`? What is expected by, for example, `void x;`? A function `void f( void );` is the same as `void f()`, does not take any parameters. — Kiril Kirov, Feb 20 '14 at 08:04
@KirilKirov: that is expected to be a compilation error. But I don't instantiate objects of type `Argument`. — Violet Giraffe, Feb 20 '14 at 08:05
Buy you _do_ specialize for this type, so the compiler can check if it's ok or not. — Kiril Kirov, Feb 20 '14 at 08:06

score 2 · Accepted Answer · edited May 23 '17 at 11:50

The specialization for this template:

template <typename Argument> class Signal
{
    void invoke(Argument arg) {}
};

would be:

template<> 
void Signal<void>::invoke(void arg)
{

}

which is illegal because you can't have a void object.

One way of doing what you want is to use overloading to declare both invoke methods, and use some templating tricks (I believe this one is called SFINAE) to only allow the correct overload available based on your class template argument:

template <typename Argument> class Signal
{
public:
    static constexpr bool IsVoid = is_same<Argument, void>::value;

    template <typename T = Argument, typename = typename std::enable_if< !IsVoid && is_same<Argument, T>::value>::type >
    void invoke(T arg) {
        // only available for non-void types
    }

    template <typename T = Argument, typename = typename std::enable_if< IsVoid >::type >
    void invoke() {
        // only available for void class specialization
    }
}


Signal<void> sv;
Signal<int> si;

sv.invoke(); // OK
si.invoke(1); // OK

sv.invoke(1); // NOT OK
sv.invoke("s"); // NOT OK
si.invoke(); // NOT OK
si.invoke("s"); // NOT OK

You can find more about the usage of enable_if here: std::enable_if to conditionally compile a member function, Why should I avoid std::enable_if in function signatures.

Thanks, this is very interesting, I didn't know of this trick nor of `std::enable_if`. — Violet Giraffe, Feb 20 '14 at 10:05
Glad you like it. I'm not an expert on SFINAE by any means, so if anyone feels like improving this, go ahead! (For instance: I couldn't find a way to do it without introducing an intermediate template type) — Martin J., Feb 20 '14 at 10:08

score 1 · Answer 2 · answered Feb 20 '14 at 10:33

What about C++11 variadic templates :

template<typename ...Args>
struct Signal {

typedef std::function<void(Args...)> slot_type;

std::list<slot_type> listeners;

template<typename Callable>
void connect(Callable callable) {
    listeners.emplace_back(callable);
}

void invoke(Args... args) {
    for(slot_type& slot : listeners)
        slot(args...);
}

};

void show_me(const std::string& data, int id) {
    std::cout << "hello " << data << " : " << id << std::endl;
}

int main() {
    Signal<std::string, int> s;
    s.connect(show_me);
    s.invoke("world", 42);
    // ...
}

It scales well with 0, 1 or more args.

Interesting! is that a working signal/slot implementation in 10 lines? Very cool, I should rewrite my classes once C++ 11 is available to me. — Violet Giraffe, Feb 20 '14 at 10:42

score 0 · Answer 3 · answered Feb 20 '14 at 08:06

If yo will try to declare a variable

void a;

you also will receive a compile error.

The problem is that compiler expects some type instead of Argument here

template <typename Argument> class Signal
{
    void invoke(Argument arg) {}
};

and void is not treated as a type here.

Class template: why can't I specialize a single method for void type?

3 Answers3

Linked