c – 模板指向函数的部分模板特化

2023年7月24日 272次阅读

请考虑以下抽象Subscription类：

template <typename TMessage>
class Subscription {
public:
    virtual ~Subscription() {}
    virtual bool handle(const TMessage &) = 0;
};

在某些情况下,如果单独一个类可以多次实现此抽象类 – 即使对于相同的TMessage – 而不是强制继承,则可能很方便.

为了实现这一点,我使用模板指针以下列方式运行：

template <typename TMessage, typename TCaller, bool(TCaller::*TMethod)(const TMessage &)>
class Invoker : public Subscription<TMessage> {
public:
    Invoker(TCaller *caller) :
        m_caller(*caller) {
    }

    virtual bool handle(const TMessage &message) {
        return (m_caller.*TMethod)(message);
    }

protected:
    TCaller &m_caller;
};

这允许创建模板生成的抽象类的实现,如下所示：
(而不是在几个不同的类中实现并在它们之间共享对象)：

struct MyMessage {};

class Logic {
public:
    Logic() :
        m_subscription1(new Invoker<MyMessage, Logic, &Logic::handleSubscription1>(this)),
        m_subscription2(new Invoker<MyMessage, Logic, &Logic::handleSubscription2>(this)) {
    }

    ~Logic() {
        delete m_subscription1;
        delete m_subscription2;
    }

    bool handleSubscription1(const MyMessage &message) {
        // handle message... uses class members
        return true;
    }

    bool handleSubscription2(const MyMessage &message) {
        // handle message... uses class members
        return false;
    }

private:
    Subscription<MyMessage> *m_subscription1;
    Subscription<MyMessage> *m_subscription2;
};

问题是,我想允许用户模块(即Logic类)实现void句柄函数以及bool选项.

现在,我当然可以创建2个不同的祈求类 – 一个实现的,就像在上面的代码,而另一个服用空隙返回函数的第三个模板参数：无效(TCaller :: * TMethod)(常量TMessage&安培).在void返回函数的handle函数中,我将调用指针函数,并返回true.

但我想知道有一种方法可以使用相同的Invoker类名,这样用户就不必将正确的Invoker与其句柄函数的返回值相匹配.有点像函数重载 – 但对于模板类.

当然如果我刚刚创建了两个具有相同名称的类(每个类采用不同的返回类型函数模板参数),编译器会尖叫重新声明模板参数.
所以我尝试使用模板部分特化来实现这一点,但是无法找到一种方法来定义第三个模板参数而不会出现编译错误 – 我甚至不确定这是正确的方法.

当我尝试这个时：

template <typename TMessage, typename TCaller, typename TMethod>
class Invoker : public Subscription<TMessage> {
};

template <typename TMessage, typename TCaller, bool(TCaller::*TMethod)(const TMessage &)>
class Invoker<TMessage, TCaller, TMethod> {
public:
    Invoker(TCaller *caller) :
        m_caller(*caller) {
    }

    virtual bool handle(const TMessage &message) {
        return (m_caller.*TMethod)(message);
    }

protected:
    TCaller &m_caller;
};

template <typename TMessage, typename TCaller, void(TCaller::*TMethod)(const TMessage &)>
class Invoker<TMessage, TCaller, TMethod> {
public:
    Invoker(TCaller *caller) :
        m_caller(*caller) {
    }

    virtual bool handle(const TMessage &message) {
        (m_caller.*TMethod)(message);
        return true;
    }

protected:
    TCaller &m_caller;
};

我在两个Invoker实现上都遇到了以下编译错误：

error: type/value mismatch at argument 3 in template parameter list for template class Invoker
error: expected a type, got TMethod

Logic类上的以下编译错误(对于每个Invoker)：

In constructor Logic::Logic():
error: type/value mismatch at argument 3 in template parameter list for template class Invoker
error: expected a type, got &Logic::handleSubscription1
error: invalid conversion from Logic* const to int
error: cannot convert int* to Subscription* in initialization

我做错了什么,这可能与模板部分专业化有关吗？
如果有任何可能的解决方案,我想知道它是否在c 11和c 98中是可行的.

谢谢.

最佳答案 你可能会这样做

template <typename TMethod, TMethod method> class Invoker;

// partial specialization for TMethod = bool(TCaller::*)(const TMessage &)
template <typename TMessage, typename TCaller, bool(TCaller::*method)(const TMessage &)>
class Invoker<bool(TCaller::*)(const TMessage &), method> :
    public Subscription<TMessage>
{
public:
    explicit Invoker(TCaller& caller) : m_caller(caller) {}

    virtual bool handle(const TMessage &message) {
        return (m_caller.*method)(message);
    }
protected:
    TCaller &m_caller;
};

// partial specialization for TMethod = void(TCaller::*)(const TMessage &)
template <typename TMessage, typename TCaller, void(TCaller::*method)(const TMessage &)>
class Invoker<void(TCaller::*)(const TMessage &), method> :
    public Subscription<TMessage>
{
public:
    explicit Invoker(TCaller& caller) : m_caller(*caller) {}

    virtual bool handle(const TMessage &message) {
        (m_caller.*method)(message);
        return true;
    }
protected:
    TCaller &m_caller;
};

用法如下：

class Logic {
public:
    Logic() :
        m_subscription1(std::make_unique<Invoker<decltype(&Logic::handleSubscription1), &Logic::handleSubscription1>>(*this)),
        m_subscription2(std::make_unique<Invoker<decltype(&Logic::handleSubscription2), &Logic::handleSubscription2>>(*this)) {
    }

    bool handleSubscription1(const MyMessage &message) {
        // handle message... uses class members
        return true;
    }

    void handleSubscription2(const MyMessage &message) {}

private:
    std::unique_ptr<Subscription<MyMessage>> m_subscription1;
    std::unique_ptr<Subscription<MyMessage>> m_subscription2;
};
点赞