我在一些 C++ 代码中有一个调度表。它将标签映射到可以处理这些标签的函数。在第一个版本中，它采用接受两个字符串并返回一个字符串的函数。字符串是序列化的 protobuf。

map<string, function<string(const string& serialised_1,
                            const string& serialised_2)>> converters = {
...
{ 'dog', ProcessTwoDogs },
{ 'cat', ProcessTwoCats },
...
};

这里的转换器函数看起来像这样

string ProcessTwoDogs(const string& dog_1_str, const string& dog_2_str);

在实现了相当多的此类转换器之后，我意识到它们通常超过了一半的样板文件:错误检查、反序列化、序列化等。因此我编写了一个快速模板，极大地简化了我的代码:

template <typename ProtoT>
std::string ConvertProtos(
    const std::string& proto_str_a,
    const std::string& proto_str_b,
    std::function<ProtoT(const ProtoT&, const ProtoT&)> convert_proto) {
    ProtoT proto_a = ...;
    ProtoT probo_b = ...;
    // and various error checks.
    ProtoT proto_out = convert_proto(proto_a, proto_b);
    // some more checks, and serialise to proto_out_str.
    return proto_out_str;
}

现在 convert_proto() 看起来像这样:

Dog ProcessTwoDogs(const Dog& dog_1, const Dog& dog_2) { ... }

这很好，但是现在我破坏了调度表，因为每个动物处理器都有不同的签名，因为 Dog 和 Cat 都是 protobufs但除此之外是无关的。我不知道如何在不求助于很长一段 if ... else if .... 的情况下制作调度表。

我想要的是这样一张 map :

// Doesn't compile.
map<string, 
   template<typename ProtoT>function<ProtoT(const ProtoT&, const ProtoT&)>>

然后是我的函数，它使用了调度表，目前是这样的

auto processor = the_map.at(tag);
string new_string = processor(string_1, string_2);

成为

auto processor = the_map.at(tag);
string new_string = ConvertProtobufs(string_1, string_2, processor);

当然，一种方法是使用接受字符串的 operator() 定义一个抽象基类，然后为我的每个转换函数实现该类的一个实例。 operator() 调用一些仅在派生类中定义的函数。但现在我失去了我可能发现的可读性或简洁性方面的任何收获。

有什么建议吗？

更新

根据@felix 提出的一系列推理，我这样写:

#include <functional>
#include <iostream>
#include <map>
#include <string>

using std::cout;
using std::function;
using std::endl;
using std::map;
using std::string;

struct Dog {
    void operator()() { cout << "I am a dog." << endl; }
};
struct Cat {
    void operator()() { cout << "I am a cat." << endl; }
};

string cat = string("cat");
string dog = string("dog");

template<string& s> void fn() { cout << "I am lost" << endl; }
template<> void fn<dog>() { Dog dog; dog(); }
template<> void fn<cat>() { Cat cat; cat(); }

int main(int argc, char *argv[]) {
    (void)argc;
    (void)argv;
    fn<dog>();
    fn<cat>();
    // Oops, it all falls apart here:
    string dog1("dog");
    fn<dog1>();   // Doesn't compile, and a dog is not a dog1.
}

上面的问题是模板参数当然必须在编译时知道。当我使用来自字符串本体的 const 字符串时，这很好，但如果字符串通过数据库传递，则失败，因此查找是基于值而不是对象的动态查找。

最佳答案

你还想要map<string, function<string(const string&, const string&)>> ，您只想以不同的方式填充它:

using converter = function<string(const string&, const string&)>;

map<string, converter> converters = {
    ...
   { "dog", convert_protos(ProcessTwoDogs) },
   { "cat", convert_protos(ProcessTwoCats) },
    ...
};

现在您需要一个返回转换器的函数模板，您可以将其与任何 ProcessTwoDogs 一起使用, ProcessTwoCats你有什么。

template <typename P_Res, typename P_A, typename P_B> 
converter convert_protos(P_Res (*processor)(P_A, P_B)) {

    return [](const string& s_a, const string& s_b) -> string
       {
          // some error checks
          P_A p_a = deserialize<P_A>(s_a);
          P_B p_b = deserialize<P_B>(s_a);
          // some more error checks
          P_Res p_res = processor(p_a, p_b);
          // yet more checks
          string s_res = serialize(p_res);
          // last final checks
          return s_res;
       };
}

关于具有模板化函数的 C++ 调度表，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42162577/