"Best fit" C++中插件的动态类型匹配

一个选项是在插件基类中有一个函数：

virtual std::string id() const { return "Plugin"; }

哪些派生类可以覆盖，例如Grandson知道它的基类是Mother，所以可能会编码：

override std::string id() const { return "Grandson " + Mother::id(); }

这样，当你在一个插件上调用id()时，你会得到类似于"祖母插件"的东西。你可以把它抛出std::stringstream ss(id);，我们抛出while (ss >> plugin_id)，然后用plugin_id作为表面容器中的键进行搜索。。。。

我认为您不会找到灵活使用typeid或dynamic_cast的方法，因为typeid不会告诉您基类(*)，dynamic_cast必须知道它在编译时要测试的类型。我想你希望能够使用新的插件，并更改一些文件或其他配置的id->surface映射，而不需要编辑你的代码。。。。

(*)如果您准备成为非标准，并且它符合您的可移植性要求，C++：使用typeinfo测试类继承文档是在运行时获得基类typeinfo的一种方法。

经过思考，我意识到以下内容应该有效：

由于表面类型应该已经用它们各自的"目标插件类型"进行标记，我意识到它们还不如在其中硬编码类型(因为一旦编译了表面插件，它就不会改变。无论如何，这基本上就是C#中类型标记的方式-尽管它是使用Attributes.Duh类完成的)。

这意味着，只要"可分配性"检查是在每个表面类内部进行的(内部知道它的目标类型)，而不是在全局函数中进行的(需要同时告知检查的源和目标类型，因此出现了问题)，它就变成了具有已知目标类型(即表面的目标插件类型)的常规强制转换操作。

我想相关的函数可以被模板化，这样模板类型T将代表他们的"目标插件类型"，以及已知的转换目的地类型。

它可能有这样的功能：

bool TargetTypeIsAssignableFrom(Plugin* plugin)

并且该函数将返回常规CCD_ 26的结果(即

dynamic_cast<T>(plugin)

因此，当执行plugin->表面匹配时，不是根据全局函数中每个表面的TargetType检查pluginType(需要同时提供这两种类型)，每个表面都会被简单地询问它们与有问题的插件的兼容性，它通过尝试对其已知T-的dynamic_cast进行测试，并且返回CCD_。

最后，对候选对象的TargetTypes进行相互检查，以确定最佳匹配。

这是一个快速而肮脏但功能性的过程说明(请原谅我的C++)：

#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Plugin {
protected:
string _name;
public:
Plugin() { _name = "Plugin"; };
virtual string Name() { return _name; }
};
class Plugin_A : public Plugin {
public:
Plugin_A() { _name = "Plugin_A"; };
};
class Plugin_B : public Plugin_A {
public:
Plugin_B() { _name = "Plugin_B"; };
};
class Plugin_C : public Plugin {
public:
Plugin_C() { _name = "Plugin_C"; };
};
Plugin * Global_Plugin = new Plugin;
Plugin_A * Global_Plugin_A = new Plugin_A;
Plugin_B * Global_Plugin_B = new Plugin_B;
class Surface {
protected:
string _name;
public:
Surface() { _name = "Surface"; };
string Name() { return _name; }
virtual Plugin* TargetType() { return Global_Plugin; }
virtual bool CanHost(Plugin* plugin) { return dynamic_cast<Plugin*>(plugin) != nullptr; } // TargetType: Plugin
};
class Surface_A : public Surface {
public:
Surface_A() { _name = "Surface_A"; };
Plugin* TargetType() { return Global_Plugin_A; }
bool CanHost(Plugin* plugin) { return dynamic_cast<Plugin_A*>(plugin) != nullptr; }  // TargetType: Plugin_A
};
class Surface_B : public Surface_A {
public:
Surface_B() { _name = "Surface_B"; };
Plugin* TargetType() { return Global_Plugin_B; }
bool CanHost(Plugin* plugin) { return dynamic_cast<Plugin_B*>(plugin) != nullptr; }  // TargetType: Plugin_B
};
vector<Surface*> surfaces;
Surface * GetSurface(Plugin* plugin) {
vector<Surface*> candidates;
cout << "Candidate surfaces for " << plugin->Name() << ":" << endl;
for (auto i = begin(surfaces); i != end(surfaces); ++i) {
if ((*i)->CanHost(plugin)) {
cout << "t" << (*i)->Name() << endl;
candidates.push_back(*i);
}
}
int bestFit = 0, fit;
Surface * candidate = nullptr;
for (auto i = begin(candidates); i != end(candidates); ++i) {
fit = 0;
for (auto j = begin(candidates); j != end(candidates); ++j) {
if (j == i || !(*j)->CanHost((*i)->TargetType())) continue;
++fit;
}
if (candidate != nullptr && fit <= bestFit) continue;
bestFit = fit;
candidate = *i;
}
cout << "Best fit for " << plugin->Name() << ":" << endl;
cout << "t" << candidate->Name() << endl;
return candidate;
}
int main() {
Surface * s[3];
s[0] = new Surface;
s[1] = new Surface_A;
s[2] = new Surface_B;
for (int i = 0; i < 3; ++i) {
surfaces.push_back(s[i]);
}
Plugin * p[3];
p[0] = new Plugin_A;
p[1] = new Plugin_B;
p[2] = new Plugin_C;
for (int i = 0; i < 3; ++i) {
GetSurface(p[i]);
cout << endl;
}
for (int i = 0; i < 3; ++i) {
delete p[i];
delete s[i];
}
cin.get();
delete Global_Plugin;
delete Global_Plugin_A;
delete Global_Plugin_B;
return EXIT_SUCCESS;
}

由于您来自一种具有反射功能的语言，并且正在询问C++中的类似功能，因此我建议您应该研究一下"；"模板元编程"；以及"；基于策略的设计"类型特征"；从而将这些决策推到编译时间。

在您的情况下，我建议您适当地标记类，并在编译时使用std::is_same、std::is_base_of提供的元编程技术做出这些决定，std::is_convertible、std::enable_if和std::conditional

当你似乎正在转向一个重大的重构时，关于这个主题的更好、更深入的资源实际上是Alexandrescu、Alexandrescu的书、Di Gennaro的书和David Abrahams关于这些技术的书中的所有内容。

我特别发现这些帖子在所有这些事情上都很有见地。。。

HTH，因为TMP很有趣