Question

我有一个类“A”，它暴露了模板方法foo。 Foo有一个标准的实现，它适用于B，C。它还有D的特殊实现。

class A
{
  template<typename T>
  void foo()
  {
    //standard implementation
  }

  template<>
  void foo<D>
  {
    //special implementation
  }
}

class B{};
class C{};
class D{};

int main()
{
  A<B> a1;
  A<C> a2;
  A<D> a3;
}

现在，我需要添加类E，这需要“foo”与D相同的特殊实现。有没有办法说出类似的话：对于所有类型都使用标准的foo。对于D，E（等等）的特殊实现。

class A
{
  template<typename T>
  void foo()
  {
    //standard implementation
  }

  template<>
  void foo<D && E>  <-- PseudoCode - It doesn't work
  {
    //special implementation
  }
}

class B{};
class C{};
class D{};
class E{};

int main()
{
  A<B> a1;
  A<C> a2;
  A<D> a3;
  A<E> a4;
}

我正在考虑使用特质课程。但我希望有更简单的方法来实现这一目标。感谢

Answer 1

使用Walter Brown（C ++ 1z）void_t。

#include <iostream>
#include <type_traits>

template <typename...>
using void_t = void;

template <typename T, typename = void>
struct has_bar 
  : std::false_type { };

template <typename T>
struct has_bar<T, void_t<decltype( std::declval<T&>().bar() ) > >
  : std::true_type { };

class A {
  public:
    void foo() { };
};

class B {
  public:
    void bar() { };
};

class C {
  public:
    void bar() { };
};

template <typename T> 
typename std::enable_if<!has_bar<T>::value, void>::type
fun(T t) {
  std::cout << "fun" << std::endl;
}

template <typename T>
typename std::enable_if<has_bar<T>::value, void>::type
fun(T t) {
  std::cout << "special fun" << std::endl;
}

代码......

int main(const int argc, const char* argv[argc]) {

  A a;
  B b;
  C c;

  fun(a);
  fun(b);
  fun(c);

  return 0;
}

打印出来

fun
special fun
special fun

注意，这不会检查任何类型的语义，因此最好将bar()声明为接口并使用std::is_base_of。

Answer 2

你应该看看SFINAE在编译时启用和禁用功能

如果D和E特殊，他们让我们说成员void bar()而不是其他成员，你可以实际实现自己的类型特征：

template<typename T>
struct has_bar {
private:
    template<typename C> static std::true_type test(decltype(&C::bar)*);
    template<typename C> static std::false_type test(...);

public:
    constexpr static bool value = decltype(test<T>(nullptr))::value;
};

                     /* false */          /* true */
cout << boolalpha << has_bar<A> << " " << has_bar<E> << endl;

现在使用此类型特征，您可以使用std::enable_if作为编译时间开关：

                                   /* standard if no bar */
template<typename T, typename = enable_if_t< !has_bar<T> >>
void foo()
{
    //standard implementation
}

                                   /* special if bar */
template<<typename T, typename = enable_if_t< has_bar<T> >>
void foo()
{
    //special implementation
}

Answer 3

AFAIK在没有定义一些SFINAE机制的情况下，你无法做到这一点。现在我能想到的最小值不包括type_traits标题如下：

定义＆＃34;自制＆＃34; enable_if和is_same类型特征如下。

namespace mine {
  template<bool, typename T = void> struct enable_if {};
  template<typename T> struct enable_if<true, T> { typedef T type; };
  template<typename T, typename U> struct is_same { static bool const value = false; };
  template<typename T> struct is_same<T, T> { static bool const value = true; };
};

将SFINAE应用于foo()的成员函数class A，如下所示：

class A {
  template<typename T>
  struct pred {
    static bool const value = mine::is_same<T, B>::value || 
    mine::is_same<T, C>::value || mine::is_same<T, D>::value || mine::is_same<T, E>::value;   
  };
public:
  template<typename T> 
  typename mine::enable_if< pred<T>::value, void>::type
  foo() { std::cout << "special implementation"  << std::endl; }

  template<typename T>
  typename mine::enable_if<!pred<T>::value, void>::type
  foo() {std::cout << "standard implementation" << std::endl; }
};

LIVE DEMO

P.S奖金是上述解决方案也适用于预编译C ++ 11编译器。

多种类型的模板方法专业化

3 个答案: