使用模板化的成员函数指针作为模板参数

Question

I have this class:

#include <assert.h>

template <typename DeclaringType, typename HandlerType>
using SubscribeMethodType = void (DeclaringType::*)(HandlerType* handler);

template <typename DeclaringType>
using UnsubscribeMethodType = void (DeclaringType::*)();

template <SubscribeMethodType<???_1, ???_2> subscribeMethod, UnsubscribeMethodType<???_1> unsubscribeMethod>
class EventHandler
{
private:
    template <typename T>
    struct ExtractDeclaringAndHandlerTypes
    {
    };

    template <typename DeclaringType, typename HandlerType>
    struct ExtractDeclaringAndHandlerTypes<void (DeclaringType::*)(HandlerType*)>
    {
        typedef DeclaringType DeclaringType;
        typedef HandlerType HandlerType;
    };

    typedef typename ExtractDeclaringAndHandlerTypes<decltype(subscribeMethod)>::DeclaringType DeclaringType;
    typedef typename ExtractDeclaringAndHandlerTypes<decltype(subscribeMethod)>::HandlerType HandlerType;

public:
    EventHandler() { }
    ~EventHandler()
    {
        Unsubscribe();
    }

    void Subscribe(DeclaringType* eventOwner, HandlerType* handler)
    {
        assert(!m_IsSubscribed);

        m_EventOwner = eventOwner;
        (eventOwner->*subscribeMethod)(handler);
        m_IsSubscribed = true;
    }

    void Unsubscribe()
    {
        if (m_IsSubscribed)
        {
            (m_EventOwner->*unsubscribeMethod)();
            m_IsSubscribed = false;
        }
    }

private:
    DeclaringType* m_EventOwner;
    bool m_IsSubscribed;
};

Example usage:

class IEventConsumer
{
};

class ExampleEventOwner
{
public:
    void Subscribe(IEventConsumer* consumer) {}
    void Unsubscribe() {}
};

int main()
{
    ExampleEventOwner owner;
    IEventConsumer consumer;

    EventHandler<&ExampleEventOwner::Subscribe, &ExampleEventOwner::Unsubscribe> handler;
    handler.Subscribe(&owner, &consumer);
    handler.Unsubscribe();

    return 0;
}

Is it possible to specify something instead of "???_1" and "???_2" to allow them to be any type? The goal is to avoid the consumer of this class having to specify DeclaringType and HandlerType explicitly, since they can easily be inferred from subscribeMethod and unsubscribeMethod.

Note: I cannot use C++17.

Answer 1

Is it possible to specify something instead of "???_1" and "???_2" to allow them to be any type?

Not before C++17, no. What you're asking for is a template non-type parameter that can deduce its type from the provided value - which is exactly what the new C++17 language feature template auto does.

Before C++17, the only way to do such a thing is to provide the type first:

template <class T, T Value> struct X;

So you have to write:

EventHandler<decltype(&ExampleEventOwner::Subscribe), &ExampleEventOwner::Subscribe,
    decltype(&ExampleEventOwner::Unsubscribe), &ExampleEventOwner::Unsubscribe
> handler;

which, admittedly, sucks. Alternatively, you could change the design to make the template parameters be the class type and handler type. This would allow you to write:

EventHandler<ExampleEventOwner, IEventConsumer> handler(
    &ExampleEventOwner::Subscribe, &ExampleEventOwner::Unsubscribe);

which in turn would let you write a factory function:

template <class T, class H>
EventHandler<void (T::*)(H*), void(T::*)()> makeEventHandler(
    void (T::*subscribe)(H*), void (T::*unsubscribe)());

auto handler = makeEventHandler(&ExampleEventOwner::Subscribe,
    &ExampleEventOwner::Unsubscribe);

And that is decidedly non-terrible.