模板类成员函数的显式特化

Question

模板类成员函数的显式特化

105

我需要为某些类型（比如double）专门化模板成员函数。当类X本身不是模板类时，它能够正常工作，但当我将它变成模板类时，GCC开始给出编译时错误。

#include <iostream>
#include <cmath>

template <class C> class X
{
public:
   template <class T> void get_as();
};

template <class C>
void X<C>::get_as<double>()
{

}

int main()
{
   X<int> x;
   x.get_as();
}

这里是错误消息

source.cpp:11:27: error: template-id
  'get_as<double>' in declaration of primary template
source.cpp:11:6: error: prototype for
  'void X<C>::get_as()' does not match any in class 'X<C>'
source.cpp:7:35: error: candidate is:
  template<class C> template<class T> void X::get_as()

这里的问题是什么，我该如何修复它？

- ledokol

2

在当前标准下，这是非法的。要进行专门化，您必须同时专门化类... - Nim

但如果类不是模板，则它可以正常工作。这也是非法的吗？ - ledokol

不，那很好，只有对于类模板才适用这个规则（据我所知）。 - Nim

3个回答

31

如果我们能够使用std::enable_if，就可以依赖于SFINAE（替换失败不是错误）。

这将像这样工作（请参见实时演示）：

#include <iostream>
#include <type_traits>

template <typename C> class X
{
public:
    template <typename T, 
              std::enable_if_t<!std::is_same_v<double,T>, int> = 0> 
    void get_as() { std::cout << "get as T" << std::endl; }

    template <typename T, 
              std::enable_if_t<std::is_same_v<double,T>, int> = 0> 
    void get_as() { std::cout << "get as double" << std::endl; }
};

int main() {
   X<int> d;
   d.get_as<double>();

   return 0;
}

丑陋的事情在于，如果编译器只有一个可用的专门化功能，则必须使用所有这些enable_if，否则会出现歧义错误。这就是为什么默认行为“获取为T”也需要启用if的原因。

- Gabriel

更新了帖子，使其更现代化。 - Gabriel

23

在C++17及其之后中，可能最干净的方法是结合使用 std::is_same_v类型特征和if constexpr，而无需明确进行特化:

#include <iostream>
#include <type_traits>

template <typename C>
class X {
  public:
    template <typename T> 
    void get_as() { 
      // Implementation part for all types
      std::cout << "get as ";

      // Implementation part for each type separately
      if constexpr (std::is_same_v<double, T>) {
        std::cout << "'double'";
      } else if constexpr (std::is_same_v<int, T>) {
        std::cout << "'int'";
      } else {
        std::cout << "(default)";
      }

      // Implementation part for all types
      std::cout << std::endl;
      return;
    }
};

int main() {
  X<int> d {};
  d.get_as<double>(); // 'double'
  d.get_as<int>();    // 'int'
  d.get_as<float>();  // (default)

  return EXIT_SUCCESS;
}

在这里试试吧！

如果你需要有一个返回类型，你可以把返回类型声明为auto：

template <typename T> 
auto get_as() { 
  if constexpr (std::is_same_v<double, T>) {
    return 0.5;
  } else {
    return 0;
  }
}

- 2b-t

2

非常优雅，可以为两个专业提供共同部分。谢谢！ - 4LegsDrivenCat

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Johannes Schaub - litb · Accepted Answer

这样行不通。你需要说以下内容，但这是不正确的。

template <class C> template<>
void X<C>::get_as<double>()
{

}

明确定义的特定成员也需要它们所在的类模板明确定义。因此，您需要使用以下语句，仅为X<int>专门化成员。

template <> template<>
void X<int>::get_as<double>()
{

}

如果您想保持周围的模板未特定化，则有几种选择。我更喜欢使用函数重载。

template <class C> class X
{
   template<typename T> struct type { };

public:
   template <class T> void get_as() {
     get_as(type<T>());
   }

private:
   template<typename T> void get_as(type<T>) {

   }

   void get_as(type<double>) {

   }
};