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

它不是那样工作的。您需要说以下内容，但这是不正确的

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

}

明确地 specialized members 也需要明确地专门化其周围的类模板。因此，您需要说出以下内容，这只会将成员专门化为 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>) {

   }
};

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

会这样工作（见 LIVE）：

#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，编译器只需要一个专业化，否则会出现消歧错误。这就是为什么默认行为“get as T”也需要启用 if。

在 C++17 及以后的版本中，最简洁的方法可能是将 if constexpr 与 std::is_same_v 类型特征结合使用，而无需明确专门化全部：

#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;
}

Try it here!

如果您还需要返回类型，可以将 返回类型 声明为 auto：

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