具有動態回調函數類型的C ++模板類

Question

在下面的代碼中，我希望用戶能夠創建具有特定類型的使用者類，例如Consumer<StateA>以便他們的回調函數可以正確處理為其提供的類型。 但是，在下面的代碼中，編譯器會抱怨，因為在編譯時，不會生成對StateB消耗方法中的函數的調用。 消費方法來自基類，必須重寫它們。

template <class T>
class Consumer : ConsumerBase
{
    public:
        Consumer(std::function<void(T&)> _callback){
            callback = _callback;
        }
        virtual void consume(StateA& state) { 
            callback(state);
        }
        virtual void consume(StateB& state) { 
            callback(state);
        }
    private:
        std::function<void(T&)> callback; 
};

基類：

class ConsumerBase
{
   public:
      virtual void consume(StateA& state) = 0;
      virtual void consume(StateB& state) = 0;
};

我該如何進行這項工作？

Answer 1

消費方法來自基類，必須重寫它們。 [...]我該如何工作？

我想一個可能的解決方案是開發幾個consume_h() （“消費助手”）方法。

第一個與調用回調函數的T （類的模板類型）完全匹配

    void consume_h (T & state)
     { callback(state); }

第二個是不做任何事情的模板版本

    template <typename U>
    void consume_h (U &)
     { }

現在，您可以覆蓋調用consume_h()兩個虛擬方法。

    virtual void consume (StateA & state)
     { consume_h(state); }

    virtual void consume (StateB & state)
     { consume_h(state); }

這樣，對應於T的虛擬方法調用了調用回調的consume_h() 。 另一個調用consume_h()的模板consume_h() 。

以下是完整的編譯示例

#include <functional>

struct StateA { };
struct StateB { };

struct ConsumerBase
 {
   virtual void consume (StateA &) = 0;
   virtual void consume (StateB &) = 0;
 };

template <typename T>
class Consumer : ConsumerBase
{
    public:
        Consumer (std::function<void(T&)> cb0) : callback{cb0}
         { }

        void consume_h (T & state)
         { callback(state); }

        template <typename U>
        void consume_h (U &)
         { }

        virtual void consume (StateA & state)
         { consume_h(state); }

        virtual void consume (StateB & state)
         { consume_h(state); }

    private:
        std::function<void(T&)> callback; 
};

int main()
{
   Consumer<StateA>  csa{[](StateA &){ std::cout << "A" << std::endl; }};
   Consumer<StateB>  csb{[](StateB &){ std::cout << "B" << std::endl; }};

   StateA  sa;
   StateB  sb;

   csa.consume(sa);  // print A
   csb.consume(sb);  // print B
}