基于模板参数的模板参数的类专用化
Class specialization based on the template argument's template argument
我有一个在FooDerived<T>中派生的模板类Foo<T>，它又是模板类Bar<T>的模板参数，也就是说，我最终得到了类似Bar< FooDerived<T> >的东西。
template <typename T>
class Foo
{
public:
typedef T type_t;
virtual double compute() { return 1.0; }
};
template <typename T>
class FooDerived : public Foo<T>
{
public:
double compute() { return 42.0; }
};
template <typename T>
class Bar : public T
{
public:
void f()
{
// This function could vary depending on U (and possibly T)
std::cout << "Bar< T<U> > : " << this->compute() << std::endl;
}
};
我试图基于FooDerived的模板参数来专门化Bar。例如，Bar< FooDerived<int> >和Bar< FooDerived<float> >将具有不同的行为。
int main(void)
{
Bar< FooDerived<int> > a;
a.f();
Bar< FooDerived<float> > b;
b.f();
}
如何在C++03（或C++11）中有效地实现这一点？所谓高效，我的意思是我希望避免无用的代码重复（实际程序涉及的类型和函数比本例中多得多）。此外，使用代码的人应该能够在不需要修改代码的情况下添加他们的专业化，因此任何类型的类似switch的解决方案都不适用。
我一直在寻找涉及boost::mpl的类似SFINAE的解决方案，例如boost::mpl::if_和boost::is_same来检查类型，但似乎没有实现我的目标。我想这可能不适合那种模板专业化。我总是使用error: redefinition of 'Bar'，因为编译器似乎并不认为它是一种专业化，例如，如果我尝试做这样的事情：
模板类栏：公共T，私有提升：：mpl:：if_，int，提升：：mpl:：false_>
使用boost::mpl::if_，无论是作为私有继承还是作为额外的模板参数，似乎都无法实现专门化。
那么，实现这样的目标的正确方法是什么呢？
更新1
将所有案例专门化是可能的，但这个例子背后隐藏的真正问题实际上要复杂得多。我有一个CachedFunction<T> : public T，其中T源自Function<U>（函数、可微函数、二次可微函数等），其中U是存储类型（密集或稀疏矩阵）。CachedFunction包含大量函数，这些函数的实现取决于存储类型和函数类型。因此，元编程似乎是避免一些代码重复的好方法。
更新2
针对提供的答案：我正在努力避免对所有涉及的案件进行这些明确的模板专门化。试着想象Foo派生出3或4个类，Foo有2或3个类型，Bar包含6或7个函数，这些函数需要根据Foo的类型和所考虑的派生类进行不同的处理。基本上，对于每个i、j和k，我都需要实现：
template<> void Bar<FooDerived_i<Type_j> >::f_k(){ ... }
因此，我想看看是否还有其他"更清洁"的方式。
更新3
如果我使用boost::is_same，我可以这样做，但这种解决方案使在不修改代码的情况下处理新类型变得更加困难。
这里有一个例子：
#include <iostream>
#include <boost/type_traits/is_same.hpp>
typedef int type1;
typedef float type2;
template <typename T>
class Foo
{
public:
typedef T type_t;
virtual double compute() { return 1.0; }
};
template <typename T>
class FooDerived
{
public:
typedef T type_t;
double compute() { return 42.0; }
};
template <class T>
class Bar : public T
{
public:
void f()
{
// types have to be known...
if (boost::is_same<typename T::type_t, type1>::value)
std::cout << "Bar< T<type1> > : " << this->compute() << std::endl;
else if (boost::is_same<typename T::type_t, type2>::value)
std::cout << "Bar< T<type2> > : " << this->compute() << std::endl;
}
};
int main(void)
{
Bar< Foo<type1> > a;
a.f();
Bar< FooDerived<type2> > b;
b.f();
}
（注意，这回答了问题的第一个版本如果你认为它应该删除，请通过评论告诉我）
你可以做：
template <typename T>
class Bar : public T
{
public:
std::string name();
};
template<>
std::string Bar<FooDerived<int> >::name() {
return std::string("int");
}
template<>
std::string Bar<FooDerived<float> >::name() {
return std::string("float");
}
此处测试：http://coliru.stacked-crooked.com/view?id=9054d3356f438b31b1adbb595620d838-ad7854d9cfd7979d567ca413f0830b65
感谢日本政府的宝贵建议！
这个怎么样？
template<>
struct Bar< FooDerived<int> >
{
// int spezialisation here
};
template<>
struct Bar< FooDerived<float> >
{
// float spezialisation here
};
对于只专门化几个具有不同行为但没有不同签名的函数，有以下方法：
template<>
std::string Bar<FooDerived<float> >::name() {
return std::string("float");
}
更新：
作为你第二次更新的注意事项，我认为在这种情况下，专业化是实施不同行为的唯一干净方法。但是，如果以更细粒度的方式使用模板，当然可以重用大量代码：
template<class T>
std::string name_impl(T& t) {
// generic implementationm
}
std::string name_impl(Bar<FooDerived<float>& t) {
// implementation
}
template<class T>
std::string Bar<T>::name() {
// something befor
return name_impl(*this);
}
因此，您可以通过函数重载切换到编译时多态性（带有继承、enable_if…），这可能比模板专业化更容易。这是编译时的模板模式。
编辑：作为对你的第三次更新，我建议在这里阅读我的答案。在您的实现中，您很可能会在方法f中遇到问题。
正如您在一条评论中所说，在真实世界的示例中，专门化类会涉及大量代码重复，因此应避免。
如果你想，正如你在问题中所说的，对Foo（或FooDerived）的模板参数"specialize"，你可能应该考虑在Bar中定义一个模板模板参数，因为否则你肯定可以实例化一个Bar，例如，因此Bar的模板参数没有模板参数。
你可以通过
template <template<typename> class T, typename Arg> class Bar : public T<Arg> {
public:
std::string name()
{
return "Bar<T<Arg>>";
}
};
也就是说，下面的代码显示了一种方法，该方法可以用于获得专门的行为，而无需专门化整个类
1 #include <string>
2 #include <iostream>
3
4 namespace ExampleSpecializations{
5 template <typename T>
6 std::string name(){
7 return "generic";
8 }
9 template <>
10 std::string name<int>(){
11 return "int";
12 }
13 }
14
15 template <typename Arg>
16 struct Bar {
17 std::string name()
18 {
19 std::string ret = std::string("Bar<") + ExampleSpecializations::name<Arg>() + std::string(">");
20 return ret;
21 }
22 };
23
24 int main()
25 {
26 Bar<int> a;
27 std::cout << a.name() << std::endl;
28 Bar<char> b;
29 std::cout << b.name() << std::endl;
30 }
31
请注意，使用外部函数（从第4行到第13行）也提供了良好的封装，因为您不添加不需要访问所涉及类内部任何内容的成员函数。
1 #include <string>
2 #include <iostream>
3
4 template <typename T>
5 struct Foo1{
6 };
7
8 template <typename T>
9 struct Foo2{
10 };
11
12 namespace ExampleSpecializations{
13 template <typename T>
14 std::string name(const T& ){
15 return "generic";
16 }
17 template <>
18 std::string name(const int&){
19 return "int";
20 }
21 template <typename T>
22 std::string name(const Foo1<T>& ){
23 std::string ret = "Foo1<" + ExampleSpecializations::name<T>(T()) + ">";
24 return ret;
25 }
26 template <typename T>
27 std::string name(const Foo2<T>& ){
28 std::string ret = "Foo2<" + ExampleSpecializations::name<T>(T()) + ">";
29 return ret;
30 }
31 }
32
33 template <typename Arg>
34 struct Bar {
35 std::string name()
36 {
37 std::string ret = std::string("Bar<") + ExampleSpecializations::name<>(Arg()) + std::string(">");
38 return ret;
39 }
40 };
41
42 int main()
43 {
44 Bar<int> a;
45 std::cout << a.name() << std::endl;
46 Bar<char> b;
47 std::cout << b.name() << std::endl;
48
49 Foo1<int> f1i;
50 std::cout << ExampleSpecializations::name(f1i) << std::endl;
51
52 Foo2<int> f2i;
53 std::cout << ExampleSpecializations::name(f2i) << std::endl;
54
55 Bar<Foo2<int> > bf2i;
56 std::cout << bf2i.name() << std::endl;
57 }
试试这里的代码不用说，我建议也将Bar:：name作为一个非成员函数。
最后，如果你不想提供一个"通用"行为，你只需要不提供一个默认的实现，如：
template <typename T>
std::string name(const T& );
通过这种方式，前面的代码会发出一个错误，因为在Bar上调用了"name"方法。该错误要么注释掉第47行，要么实现字符专用化。
- 具有常量引用参数的函数模板专用化
- 通过依赖类型使用非类型模板参数的单类型模板参数类模板的部分专用化
- 具有多个参数的模板化类专用化，其中一个模板参数是模板本身
- 具有可变参数非类型参数的模板专用化
- 类专用化，没有用作专用化模板参数的类的模板参数
- 基于枚举参数调用专用模板方法
- 检查类是否具有模板专用化(使用布尔值或 int 等模板参数）
- 专用于可变参数模板成员函数
- 如何将模板类专用化为也接受模板模板参数
- 调用模板专用化，具有更多参数的单参数模板调用的特定值
- 有没有办法根据 lambda 参数返回类型部分专用化我的模板化函数?
- C++ 将派生类的成员函数指针作为参数传递时选择了错误的模板专用化
- cpp 模板专用化，错误说参数 1 的类型为 T，这取决于参数 T
- 具有不同非类型模板参数的模板类部分专用化
- 带有void类型和参数的C++11模板专用化
- 如何进行模板化类型化参数专用化?
- C++具有可变参数专用参数的模板，用于参数数量
- 使用类型参数专用化部分模板参数(VC++ v140 工具集）
- 模板模板可变参数专用化
- 将可变模板模板参数专用于最小数量的参数:合法或不合法
