Question

我正在设置一个c ++（11）程序，其中我使用依赖于2个参数的模板化类。大部分类可以一般地写在模板参数上。只有少数功能需要专门的版本。这是一个重现我的问题的示例模式：

template<class T, int N> 
class foo
{
  // typedefs and members that depend on T and N
  // but that can be written generically e.g. :
  typedef std::array<T,N> myarray;
  void myfunc(myarray tab);
};

// ...

template<class T, int N>
foo<T,N>::myfunc(myarray tab)
{
  // generic version
}

// need specialization only of myfunc:
template<class T>
foo<T,1>::myfunc(myarray tab)
{
  // specialized version for N=1
}

然后编译器抱怨：error: invalid use of incomplete type ‘class foo<T, 1>’大约然后行template<class T> foo<T,1>::myfunc(myarray tab)

我发现工作的唯一解决方法是使用其专用版本插入完整的类副本：

template<class T>
class foo<T,1>
{
  // recopy all the lines of class foo<T,N>, replacing N by 1
};
// duplicate as well all generic function definition with 
// specialized versions <T,1> even when not needed

非常不满意......

经过一些实验，我发现当模板仅使用1个参数（例如template <int N> class foo{...};）时似乎不会出现此问题，但仅在涉及至少2个参数时才会出现此问题。

这是C ++编程中众所周知的吗？有没有更聪明的方法来解决我的问题？（我想创建一个没有专门函数的母类，然后让类foo继承它，只保留它的专门成员，以便最小化＆＃34;复制解决方法＆＃34;）

感谢您的建议！

Answer 1

标记派遣救援。

使用std::integral_constant，我们可以创建两种类型，一种用于通用N，另一种用于1（或者您可以在int上定义一些其他类型模板，但我选择使用已经存在的东西。）

void myfunc(myarray tab)
{
    myfunchelper(tab, 
       typename std::is_same<std::integral_constant<int, N>,
                             std::integral_constant<int, 1>>::type{});
}

调用对std::true_type重叠的辅助函数的调用（N==1}和std::false_type（N != 1}的场景：

void myfunchelper(myarray tab, std::false_type);
void myfunchelper(myarray tab, std::true_type);

注意我故意不为该类型命名，因为它没有被使用，而智能编译器将优化该类型的任何类型的分配（我认为）。

Live Demo

（以下演示代码）：

#include <array>
#include <iostream>
#include <type_traits>

template<class T, int N> 
class foo
{
public:
  // typedefs and members that depend on T and N
  // but that can be written generically e.g. :
  typedef std::array<T,N> myarray;
  void myfunc(myarray tab)
  {
      myfunchelper(tab, typename std::is_same<std::integral_constant<int, N>, std::integral_constant<int, 1>>::type{});
  }

private:
  void myfunchelper(myarray tab, std::false_type)
  {
      std::cout << "Generic myfunc\n";
  }
  void myfunchelper(myarray tab, std::true_type)
  {
      std::cout << "myfunc specialized for N==1\n";
  }
};

int main()
{
    std::array<char, 1> arr1{{'c'}};
    std::array<double, 2> arr2{{1.0, 2.0}};
    foo<char, 1> f1;
    foo<double, 2> f2;
    f1.myfunc(arr1); // calls specialized version
    f2.myfunc(arr2); // calls generic version
}

关于您发布的解决方案，这也是一种标记调度方法，它涉及定义另一个int - 模板类，它将不必要的类型引入周围的范围，还涉及转换a和{ {1}}（在这种情况下，0，NULL通常是typedef＆＃39; d as）。

实际上，我发布的解决方案是相同的，但我认为它更清晰，更安全一点。

Answer 2

简短回答：您可以通过这种方式完全专注于会员，但您无法对其进行部分专业化。

答案很长：当您的班级只有一个模板参数时，例如：

template <class T> struct X {
   void foo() { };
}

template <> void X<int>::foo() {  }

是完全专业化，并且是允许的。然而，

template <class T, class Y> struct X {
   void foo() { };
}

template <class T> void X<int, Y>::foo() {  }

是否部分特化，并且不允许单个成员的部分特化 - 您需要部分专门化整个类。

Answer 3

用Google搜索Specialization of templated member function in templated class并调整Matthieu M.'sansans，我认为我找到了一个解决方案（重载）来解决我的问题：

template<int N> class virtualclass{};

template<class T, int N> 
class foo
{
  // typedefs and members that depend on T and N
  // but that can be written generically e.g. :
  typedef std::array<T,N> myarray;
  void myfunc(myarray tab)
  {
     helperfunc((virtualclass<N>*)0, tab);
  }

  template<class P>
  void helperfunc(P*, myarray tab);

  void helperfunc(virtualclass<1>*, myarray tab);
};

// ...

template<class T, int N>
template<class P>
foo<T,N>::helperfunc(P*,myarray tab)
{
  // generic version
}

// need specialization only of myfunc:
template<class T, int N>
foo<T,N>::helperfunc(virtualclass<1>*, myarray tab)
{
  // specialized version for N=1
}

它看起来像是一种好习惯吗？这个解决方案可能存在一些隐藏的缺点吗？

c ++多参数模板化类成员特化

3 个答案:

Live Demo