Question

您好我在选择具有明确特化的模板化类的正确版本时遇到问题。我想要使用用于专门化的类的派生类来选择特化。场景是：

#include <stdio.h>

class A
{};

class B: public A
{};

template<typename T>
class Foo
{
public:
   int FooBar(void) { return 10; }
};

// Explicit specialization for A
template<> int Foo< A >::FooBar( void ) { return 20; }

void main( void)
{
   Foo<B> fooB;

   // This prints out 10 instead of wanted 20 ie compiler selects the general version
   printf("%d", fooB.FooBar() );
}

正如我在评论中所说，我希望看到20被打印出来，因为B是从A派生出来的，而10则是打印出来的。如何在不使用为每个派生类编写专门化的情况下获得名为的专门化（我的实际场景很多派生类型）。

Answer 1

---编辑：新的答案让我们让原始方法更易于维护。所有重要的选择都可以在Foo的定义中找到。它应该易于维护。

#include <boost/mpl/if.hpp>
#include  <boost/type_traits/is_base_of.hpp>
#include <iostream>

class A
{};

class B: public A
{};

class C{};
class D : public C{};
class E{};

struct DefaultMethod
{
    static int fooBar() { return 10; }
};
struct Method1
{
    static int fooBar() { return 20; }
};
struct Method2
{
    static int fooBar() { return 30; }
};

template<typename T, typename BaseClass, typename Choice1, typename OtherChoice>
struct IfDerivesFrom :
    boost::mpl::if_<
        typename boost::is_base_of<BaseClass, T>::type,
        Choice1,
        OtherChoice>::type
{
};

template<typename T>
struct Foo :
    IfDerivesFrom<T, A,
      Method1,
      IfDerivesFrom<T, C,
          Method2,
          DefaultMethod>
      >
{
};

int main()
{
    std::cout << Foo<A>::fooBar() << std::endl;
    std::cout << Foo<B>::fooBar() << std::endl;
    std::cout << Foo<C>::fooBar() << std::endl;
    std::cout << Foo<D>::fooBar() << std::endl;
    std::cout << Foo<E>::fooBar() << std::endl;

    return 0;
}

---原始答案如果您可以使用boost，您可以执行以下操作：

#include  <boost/type_traits/is_base_of.hpp>

template<bool b>
class FooHelper
{
    int FooBar();
};
template<> FooHelper<true>::FooBar(){ return 20;}
template<> FooHelper<false>::FooBar(){ return 10;}

template<typename T>
class Foo
{
public:
   int FooBar(void) { return FooHelper<boost::is_base_of<A, T>::type::value>(); }
};

Answer 2

更一般地说，这是模板和继承的长期问题。

问题是模板在确切类型上工作而不考虑继承因素，这两个概念在某种程度上是正交的，因此尝试混合一个和另一个通常容易出错。

你也可以用方法检查出来：

template <class T>
int fooBar(T) { return 10; }

int fooBar(A) { return 20; }

B b;
fooBar(b); // this returns 10, because fooBar<T> is a better match (no conversion)

现在，关于你的问题，虽然我很欣赏使用enable_if和is_base_of技巧给出的各种解决方案，但我认为它们不实用。专业化的一点是Foo的作者不必知道如果有必要，任何人都会如何专注于她的课程，只是为了让它变得简单。否则，如果您需要十几个专业化，那么最终会得到一个非常奇怪的Foo类，这是肯定的。

STL已经处理过类似的问题。接受的习语通常是提供特质课程。默认traits类为每个人提供了一个很好的解决方案，同时可以专门设置一个traits类来满足一个人的需要。

我认为应该有一种方法使用Concepts（即，如果T定义T :: fooBar（）然后使用它，否则使用默认版本...），但是对于方法重载的具体方法，这不是必需的。

namespace detail { int fooBar(...) { return 10; } }

template <class T>
class Foo
{
public:
  static int FooBar() { T* t(0); return ::detail::fooBar(t); }
};

现在，专门研究A：

的派生类

namespace detail { int fooBar(A*) { return 20; } }

它是如何运作的？在考虑重载时，省略号是考虑的最后一种方法，因此任何符合条件的方法都可以，因此它对于默认行为是完美的。

一些注意事项：

命名空间：取决于标识符fooBar是否可能被使用，您可能更愿意隔离到自己的命名空间（或专用于Foo类），否则，进行无条件的调用，让用户在她的类的命名空间中定义它。
这个技巧仅适用于继承和方法调用，如果你想引入特殊的typedef它不起作用
您可以将更多模板传递给实际方法，例如真实类型

以下是模板函数的示例

namespace detail { template <class T> int fooBar(...) { return 10; } }

template <class T>
int Foo<T>::FooBar() { T* t(0); return ::detail::fooBar<T>(t); }

namespace detail {
  template <class T>
  int fooBar(A*)
  {
    return T::FooBar();
  }
}

这将会发生什么：

struct None {};
struct A { static int FooBar() { return 20; } };
struct B: A {};
struct C: A { static int FooBar() { return 30; } };

int main(int argc, char* argv[])
{
  std::cout << Foo<None>::FooBar()  // prints 10
     << " " << Foo<A>::FooBar()     // prints 20
     << " " << Foo<B>::FooBar()     // prints 20
     << " " << Foo<C>::FooBar()     // prints 30
     << std::endl;
}

Answer 3

第一（次要）要点：你的头衔是不正确的;这是明确的专业化，而不是部分专业化。要获得部分特化，您需要指定至少一个模板参数，但至少保留一个未指定的参数：

template <class T, class U>
demo { };

template <class T>
demo<int> {};  // use in the case of demo<XXX, int>

看看你的代码，我对它的编译感到有些惊讶。我不确定你是否可以强制调用你的专用函数。通常情况下，你会将整个班级专门化：

template<typename T>
class Foo
{
public:
   int FooBar(void) { return 10; }
};

template<>
class Foo<A> {
public:
    int FooBar() { return 20; }
};

在这种情况下，这对你没有任何好处。您可以隐式地将派生对象转换为基础对象，但仍然是转换。另一方面，模板的非专用版本可以与 no 转换一起使用 - 当选择使用哪一个时，编译器会将一个可以实例化而没有转换的处理视为更好选择而不是需要隐式转换的选择。

Answer 4

这是一个解决方案，但它并不是特别好：

template<typename T>
class Foo
{
public:
  int FooBar(typename disable_if<boost::is_base_of<A,T> >::type* dummy = 0) { return 10; }
  int FooBar(typename enable_if<boost::is_base_of<A,T> >::type* dummy = 0) { return 20; }
};

Answer 5

您需要专注于确切类型。例如，Foo<A> fooA; fooA.FooBar();可以获得20。或者使用boost.type_traits作为@Benoît显示。

Answer 6

从根本上说，您希望在派生类上具有模板特化触发器。

如果你不需要专门的实际类，只需要函数，你似乎可以这样做：

int foo::foobar(A &someA);

如果你真的需要让这个类专门化，我想你想看看接口和私有类数据模式;或多或少，接口将一个对象“简化”为一个模板特化识别类型，然后通过调用;翼

int foo::foobar(A &someA)
{ return fooImpl<A>::foobar(someA); }

但我认为这并不能真正回答你的问题，因为它不支持通用案例。我想你可以：

template<class T>
class foo
{
public: 
    int foobar(T &t);
    int foobar(A &a);
}

foo<A>::foobar(someA);
foo<F>::foobar(someA);
foo<not B>::foobar(someB); //Should trigger foobar(A &a), right?

然后，这将能够将B识别为从A派生，同时仍然提供通用案例。我认为;我没有测试过这个。

这不是最漂亮的，但我认为你有一些机会在那里有一些有趣的访问控制的东西，如果你是专门的实际课程，因为你可以包括或不包括各种foobar（A＆amp; a）喜欢允许或拒绝在各种继承树上使用的函数;对于上面的例子;

foo<C>::foobar(someF); //doesn't exist!

根据派生类型选择类的显式特化

6 个答案: