好的，首先，在这里对问题进行解释。需要的是一个接口，它定义了一个虚拟方法，用于获取模板类型的值。由于我们想要的是一个接口，get 方法必须是虚拟的。另一方面，我们希望能够返回不同的类型，因此我们希望将其模板化。但是，虚拟方法不能被模板化，因为编译器不知道该方法的哪些实例应该包含在 vtable 中。
一种解决方案是做问题中所做的事情，即模板化接口类。模板类型的一个重要属性是同一类的不同实例化是完全不同的类型。它们没有共同的基础，也不能相互转换。我们根本不能在常规函数中使用Interface<Generic> 指针，同时调用它们的get() 方法。考虑一下：接口模板类型的每个实例都有不同的 get() 方法签名。这意味着在调用该方法时，堆栈上必须发生不同的事情。如果它只有一个Interface<Generic> 指针，编译器怎么知道要调用哪个版本的get() 方法（如何为函数调用准备堆栈）。
对于这个问题，我能想到两种通用的解决方案。
删除所有模板 mumbo-jumbo 并使 get() 方法返回一个类型擦除的对象，例如 boost::variant 或 boost::any。如果我在这里错了，请纠正我（*），但是 boost::variant 就像一个联合，它记住分配了哪种类型的联合，而 boost::any 就像一个 void *，但它记得它指向的是什么类型.该解决方案路径意味着两件事：
a) 返回对象的类型将在运行时解析，并且在操作这些类型时会有一些开销。
b) Interface 的子类必须管理这些类型擦除的对象之一，使它们更加复杂。
将模板 mumbo-jumbo 发挥到极致，并始终在模板化上下文中引用接口对象，以便编译器在这些上下文的实例化期间生成正确的函数调用。我在下面给出了一个遵循这条路径的例子。该示例创建了一个容器，用于将不同类型的 Interface 对象保存在一起，同时启用对它们的模板化功能（通常称其为“访问者”是否正确？）。请注意，在该示例中，具有不同类型参数的接口对象实际上保存在该容器类中的不同 std::list 中，因此在运行时，无需解析它们的类型。
免责声明：接下来的内容有点矫枉过正......
以下是如何拥有具有不同模板参数的“接口”模板类的容器。我使用 std::list 来保留实例，但您可以更改它。
#include<boost/fusion/container/vector.hpp>
#include<boost/fusion/algorithm.hpp>
#include<boost/mpl/transform.hpp>
#include<boost/mpl/contains.hpp>
#include<boost/utility/enable_if.hpp>
#include<boost/type_traits/add_reference.hpp>
#include<list>
#include<algorithm>
#include <iostream>
using namespace boost;
template <class T>
class Interface{
public:
typedef T Units;
virtual T get() = 0;
};
class Implementation1: public Interface<float> {
public:
float get() {
return 0.0f;
}
};
class Implementation2: public Interface<int> {
public:
int get() {
return 5;
}
};
template<class element>
struct to_list {
typedef std::list<Interface<element> *> type;
};
template<class elementVector>
struct to_containers {
typedef typename mpl::transform<elementVector,to_list<mpl::_1> >::type type;
};
class Container{
typedef fusion::vector<int,float> AllowedTypes;
typename to_containers<AllowedTypes>::type containers;
public:
template<class type> typename enable_if<mpl::contains<AllowedTypes,type>,void>::type
/*void*/ add(Interface< type/*included in AllowedTypes*/ > & floatGetter) {
fusion::deref(fusion::find<typename to_list<type>::type >(containers))
/*<type> container*/.push_back(&floatGetter);
}
template<class functional>
void apply(functional f) {
fusion::for_each(containers,applyFunctional<functional>(f));
}
private:
template<class functional>
struct applyFunctional {
functional f;
applyFunctional(functional f): f(f){}
template<class T> void operator()(T & in) const {
std::for_each(in.begin(), in.end(),f);
}
};
};
struct printValueFunctional {
template<class element>
void operator()(Interface<element> * in) const {
std::cout<<"Hi, my value is:"<<in->get()<<"\n";
}
};
int main() {
Implementation1 impl1;
Implementation2 impl2;
Interface<float> &myInterface1 = impl1;
Interface<int> &myInterface2 = impl2;
Container container;
container.add(myInterface1);
container.add(myInterface2);
container.apply(printValueFunctional());
return 0;
}
输出是：
Hi, my value is:5
Hi, my value is:0
嗯，这对于大多数应用程序来说确实是一个巨大的过度杀伤，但你要求它:)
如果你只想要一个接口，可以返回不同的东西，你也可以考虑 boost.variant。上面的示例对于它使用的所有静态多态性来说确实很有价值。
编辑：大卫指出了一些重要的事情，如果您出于某种原因假设其他情况，这可能是一个陷阱。这个容器并没有真正保持项目插入的顺序。您的函数调用的顺序可能不会按照插入项的顺序发生，即假设迭代将以“随机”顺序进行。
(*) boost::variant 和 boost::any 正在讨论here