如何根据类模板参数专业化成员函数

Question

问题怎么说。另外，是否可以进行内联？

这是一个小例子，只是为了给出一个想法...

template<typename T>
class Foo {
 public:
  Foo() :z(0.0) {}

  void do( const Foo<T> &f ) {
    z = f.z;
  }
  // specialize 'do' for Foo<int>, possible inline?

 private:
  T z;
};

Answer 1

您可以通过使成员函数为成员函数模板并使用SFINAE来获得此行为（替换失败不是错误）。例如：

template <typename U>
typename std::enable_if<!std::is_integral<U>::value && 
                        std::is_same<T, U>::value, void>::type
f(const Foo<U>& x)
{
}

template <typename U>
typename std::enable_if<std::is_integral<U>::value && 
                        std::is_same<T, U>::value, void>::type
f(const Foo<U>& x)
{
}

这 is_integral 类型特征测试是否 U 是整数类型。如果不是，则第一个是实例化的；如果是，则第二个是实例化的。

这 is_same 类型特征测试以确保 T 和 U 是相同的类型。这用于确保不针对除了任何类型的任何类型的成员函数模板 Foo<T>.

此示例利用C ++ 0x <type_traits> 图书馆; Boost也有 类型特征库 您可以使用，其工作原理大多相同。

Answer 2

您无需做任何复杂的事情。只需使用过载和委托即可。请注意，我们不能只添加 int 超载，因为什么时候 T 原来是 int 同样，这将是无效的过载（两个具有相同签名的功能）

template<typename T>
class Foo {
 public:
  Foo() :z(0.0) {}

  void doIt(const Foo<T> &f ) {
    doItImpl(f);
  }

 private:
  template<typename U>
  void doItImpl(const Foo<U> &f) {
    z = f.z;
  }

  void doItImpl(const Foo<int> &f) {
    /* ... */
  }

 private:
  T z;
};

或者，在这种情况下，您可以通过专业化来做到这一点

template<typename T>
class Foo {
 public:
  Foo() :z(0.0) {}

  void doIt(const Foo<T> &f ) {
    z = f.z;
  }

 private:
  T z;
};

template<>
inline void Foo<int>::doIt(const Foo<int> &f) {
  /* ... */
}

仅当所有模板参数均已固定时，才有可能使用专业化。换句话说，不可能部分地专业化成员函数。

Answer 3

您可能会尝试做这样的事情（没有测试，可能行不通）：

template<typename T>
class Foo {
 public:
  Foo() :z(0.0) {}

  template<typename Ty = T>
  void do( const Foo<T> &f ) {
    z = f.z;
  }

  template<>
  void do<int>( const Foo<T> &f ) {
    //specialized code
  }

 private:
  T z;
};