3

我有一些从序列化数据中读取各种类型的函数，例如：

class DataDeserializer
{
    int getInt();
    std::string getString();
    MyClass getMyClass();
}

然后我有各种带有任意参数的回调函数，例如：

void callbackA (int, int, int);
void callbackB (int, std::string);
void callbackC (std::string, int, MyClass, int);

我想用从反序列化数据流中读取的参数调用各种回调。我想要的是尽可能地自动化样板代码。我在想也许我可以使用模板。如果我有某种 Dispatcher 类，例如：

template <SOMETHING??> class Dispatcher
{
    void dispatch()
    {
        // ???? 
    }

    SOMEFUNCTIONTYPE callback;
    DataDeserializer myDeserializer;
};

然后声明各种特定的调度程序：

Dispatcher<int,int,int>                  myDispatcherA (deserializer, callbackA);
Dispatcher<int,std::string>              myDispatcherB (deserializer, callbackB);
Dispatcher<std::string,int,MyClass,int>  myDispatcherC (deserializer, callbackC);

然后当我想调度时，我只需调用：

myDispatcherB.dispatch();

下面会扩展成这样的东西：

void dispatch()
{
    callback (myDeserializer.getString(), myDeserializer.getInt(), myDeserializer.getMyClass(), myDeserializer.getInt());
}

这对 C++11 可变参数模板可行吗？我已经阅读了一些关于它们的内容，似乎递归使用了很多。

4

2 回答 2

6

我为我的stream_function班级做了类似的事情。基本思想是将类型传递给执行 The Right Thing™ 的函数模板，然后扩展该调用：

callback(magic<Args>(/* sth */)...);

但是，如果您的函数不是纯函数并修改了某些状态，并且因此需要以正确的顺序调用它们，则您必须使用一些技巧来强制该顺序。

如果您使用 Clang，这相当容易，因为它强制对支撑初始化列表进行从左到右的评估。这允许您只使用一个小的帮助类型

struct invoker{
  template<class F, class... Args>
  invoker(F&& f, Args&&... args){ f(std::forward<Args>(args)...); }
};

然后做

invoker{ callback, magic<Args>(/* sth */)... };

不幸的是，GCC 还没有实现这个功能，所以需要求助于手动执行命令。这可以通过一个小型辅助结构来完成，它只是一个类型列表，但允许人们做一些有用的事情：

  • 查看包装何时为空（types<>），以及
  • Args以头尾递归方式处理
template<class...> struct types{};

template<class... Args>
struct dispatcher{
    std::function<void(Args...)> f;

    void call(){ _call(types<Args...>{}); }
private:
    // take head, produce value from it, pass after other values
    template<class Head, class... Tail, class... Vs>
    void _call(types<Head, Tail...>, Vs&&... vs){
        _call(types<Tail...>{}, std::forward<Vs>(vs)..., get_value<Head>());
    }

    // no more values to produce, forward to callback function
    template<class... Vs>
    void _call(types<>, Vs&&... vs){ f(std::forward<Vs>(vs)...); }
};

活生生的例子。

于 2013-09-20T10:15:12.860 回答
2

像这样的东西可以帮助你

template<typename T>
T get_value(Deserializer&);

template<>
int get_value(Deserializer& d)
{
   return d.getInt();
}

template<>
std::string get_value(Deserializer& d)
{
   return d.getString();
}

template<typename... Args>
class Dispatcher
{
public:
   template<typename Functor>
   Dispatcher(Deserializer& d, const Functor& cb) : myDeserializer(d), callback(cb)
   {
   }
   void dispatch()
   {
      callback(get_value<Args>(myDeserializer)...);
   }
private:
   std::function<void(Args...)> callback;
   Deserializer myDeserializer;
};

活生生的例子

于 2013-09-17T10:46:18.660 回答