Question

我可以找到很多关于模板化类的部分特化的帮助，但我想部分地专门化一个非模板类的方法。

class TempMembMeth {
  public:
    template<typename T1, typename T2>
    void templMethod1(int);
};

我的模板化方法实现：

template<typename T1, typename T2>
  void TempMembMeth::templMethod1(int){
  std::cout << "<T1,T2>templMethod1(int)" << '\n';
}

我可以完全指定方法OK：

template<>
inline void TempMembMeth::templMethod1<char,char>(int){
    std::cout << "<char,char>templMethod1(int)" << '\n';
}

但我该如何进行部分规范？

template<typename T2>
inline void TempMembMeth::templMethod1<char,T2>(int){
    std::cout << "<char,?>templMethod1(int)" << '\n';
}

我得到：'TempMembMeth :: templMethod1'：非法使用显式模板参数我无法使用部分专用方法重新定义类，因为该类不是模板化的。它也不会让我“重载”类中的模板化方法 - 它再次抱怨非法使用显式模板参数。

所有想法是否可行？目前我通过模板化课程来解决这个问题，但我想知道如果没有模板化课程，这是否可行。

Answer 1

正如TC评论的那样，你不能部分专门化模板功能。

您应该使用重载。如有必要，可以使用Type2Type参数添加一些私有函数。类似的东西：

#include <iostream>

struct Test
{
public:

    template<typename T1, typename T2>
    void templMethod1(int i)
    {
        templMethodImpl(i, Type2Type<T1>(), Type2Type<T2>());
    }

private:

    template<typename T>
    struct Type2Type
    {
        typedef T OriginalType;
    };

    template<class T1, class T2>
    void templMethodImpl(int i, Type2Type<T1>, Type2Type<T2>)
    {
        std::cout << "t1 any, t2 any" << std::endl;
    }

    template<class T2>
    void templMethodImpl(int i, Type2Type<char>, Type2Type<T2>)
    { 
        std::cout << "t1 char, t2 any" << std::endl;
    }

    void templMethodImpl(int i, Type2Type<int>, Type2Type<char>)
    {
        std::cout << "t1 int, t2 char" << std::endl;
    }
};

int main()
{
    Test test;

    test.templMethod1<char, char>(5);
    test.templMethod1<int, char>(5);
    test.templMethod1<char, int>(5);
    test.templMethod1<int, int>(5);
}

Answer 2

正如其他人已经指出的那样，你不能部分专门化功能模板。但是，您可以使用具有几乎相同效果的辅助类。

#include <iostream>

namespace details
{
   // Forward declaration of the helper class.
   template<typename T1, typename T2> struct Helper;
}

class TempMembMeth 
{
  public:

    template<typename T1, typename T2>
    void templMethod1(int arg)
    {
       details::Helper<T1, T2>::doit(this, arg);
    }
};

namespace details
{
   // Implement the helper class and its specializations.
   template<typename T1, typename T2> struct Helper
   {
      static void doit(TempMembMeth* obj, int arg)
      {
         std::cout << "In Helper<T1,T2>::doit()\n";
      }
   };

   template<typename T2> struct Helper<char, T2>
   {
      static void doit(TempMembMeth* obj, int arg)
      {
         std::cout << "In Helper<char,T2>::doit()\n";
      }
   };

   template<> struct Helper<char, char>
   {
      static void doit(TempMembMeth* obj, int arg)
      {
         std::cout << "In Helper<char, char>::doit()\n";
      }
   };
}

int main()
{
   TempMembMeth obj;
   obj.templMethod1<float, int>(10);
   obj.templMethod1<char, double>(20);
   obj.templMethod1<char, char>(30);
   return 0;
}

输出：

In Helper<T1,T2>::doit()
In Helper<char,T2>::doit()
In Helper<char, char>::doit()

如何部分地专门化非模板化类的模板化成员方法？

2 个答案: