Question

嗯，对于一个学校项目，我的平均组长要求我做一个“CallBack”类来存储一个函数而不管它的签名，这个类最后必须存放在一个容器中。

答案是从Base类中创建一个Derived模板化类，以便我们可以存储它。问题出现在执行实际函数时，因为它需要可变数量和类型的参数，我不能使用多态来执行它。

我通过使用动态强制转换和一些模板参数（请参阅下面的代码）来尝试检索类型来避免此问题。虽然它确实适用于大多数情况，但它会导致某些签名出现大问题（例如，如果函数在参数中使用“void *”）。代码将更加健谈...我将它简化为更快，它实际上也指向成员指针。

    #include <functional>

    template <typename R, typename... Arguments>
    class CallBack;


    class ACallBack
    {
    protected:
      ACallBack()
      {
      }


    public:
      virtual ~ACallBack()
      {
      }

      template <typename R, typename... Arguments>
      R run(Arguments &&... args)
      {
        CallBack<R, Arguments...> *C;

        // Here is the problem i would like to avoid, and do it properly if possible
        if ((C = dynamic_cast<CallBack<R, Arguments...> *>(this))) 
        {
          return (*C)(std::forward<Arguments>(args)...);
        }
        return (R());
      }

      template <typename... Arguments>
      void operator()(Arguments &&... args)
      {
        run<void>(std::forward<Arguments>(args)...);
      }


      template <typename R, typename... Args>
      static CallBack<R, Args...>* generate(R(*f)(Args...))
      {
        return new CallBack<R, Args...>(f);
      }
    };

对于实际的派生类：

  template <typename R, typename... Arguments>
  class CallBack : public ACallBack
  {
  public:
    template <typename F>
    CallBack(F&& f) : _fct(std::forward<F>(f))
    {
    }

    virtual ~CallBack()
    {
    }

    R operator()(Arguments &&... args)
    {
      return (_fct(std::forward<Arguments>(args)...));
    }

  private:
    std::function<R(Arguments...)> _fct;
  };

所以，如果没有这种丑陋的方式并且功能齐全，那么任何想法都会非常感激。

总结一下：我需要通过只有一个指向基类的指针来调用派生类中存储的函数，但据我所知，由于静态模板和运行之间相反，所以不可能这样做时间多态性。

C ++ Variadic模板和虚拟方法

0 个答案: