带有模板化函数的C++调度表

我在一些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都是原蟾蜍，但在其他方面是不相关的。我不知道如何在不使用长的if ... else if ....的情况下制作调度表。

我想要的是这样的地图：

// 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字符串时，这很好，但如果字符串通过数据库，则会失败，因此查找是基于值而非对象的动态查找。