“不完整类型的无效使用” 部分模板专业化错误

Question

以下代码：

template <typename S, typename T>
struct foo {
   void bar();
};

template <typename T>
void foo <int, T>::bar() {
}

给我错误

invalid use of incomplete type 'struct foo<int, T>'
declaration of 'struct foo<int, T>'

（我正在使用 gcc。）我的部分专业化语法是否错误？ 请注意，如果我删除第二个参数：

template <typename S>
struct foo {
   void bar();
};

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

那么它会正确编译。

Answer 1

你不能部分特化一个函数。 如果您希望对成员函数执行此操作，则必须部分特化整个模板（是的，这很烦人）。 在大型模板类上，要部分专门化某个函数，您需要一种解决方法。 也许模板化成员结构（例如templatestruct Nested）会起作用。 或者，您可以尝试从另一个部分专门化的模板派生（如果您使用 this->member 表示法，则有效，否则您将遇到编译器错误）。

Answer 2

如果您需要部分专门化构造函数，您可以尝试以下操作：

template <class T, int N>
struct thingBase
{
    //Data members and other stuff.
};

template <class T, int N> struct thing : thingBase<T, N> {};

template <class T> struct thing<T, 42> : thingBase<T, 42>
{
    thing(T * param1, wchar_t * param2)
    {
        //Special construction if N equals 42.
    }
};

注意：这是我正在处理的事情的匿名内容。 当您有一个包含大量成员的模板类并且您只想添加一个函数时，您也可以使用它。

Answer 3

虽然 coppro 已经提到了两种解决方案，Anonymous 也解释了第二个，但我花了相当长的时间才理解第一个。 也许下面的代码对那些偶然发现这个网站的人有帮助，这个网站在谷歌中仍然排名很高，就像我一样。 这个示例（将 numericT 的向量/数组/单个元素作为 dataT 传递，然后通过 [] 或直接访问它）当然有些人为，但应该说明如何实际上可以通过包装它来非常接近部分专业化成员函数在部分专业课程中。

/* The following circumvents the impossible partial specialization of 
a member function 
actualClass<dataT,numericalT,1>::access
as well as the non-nonsensical full specialisation of the possibly
very big actualClass. */

//helper:
template <typename dataT, typename numericalT, unsigned int dataDim>
class specialised{
public:
  numericalT& access(dataT& x, const unsigned int index){return x[index];}
};

//partial specialisation:
template <typename dataT, typename numericalT>
class specialised<dataT,numericalT,1>{
public:
  numericalT& access(dataT& x, const unsigned int index){return x;}
};

//your actual class:
template <typename dataT, typename numericalT, unsigned int dataDim>
class actualClass{
private:
  dataT x;
  specialised<dataT,numericalT,dataDim> accessor;
public:
  //... for(int i=0;i<dataDim;++i) ...accessor.access(x,i) ...
};

Answer 4

如果您正在阅读这个问题，那么您可能需要提醒，虽然您不能部分专门化方法，但您可以添加非模板化重载，该重载将优先于模板化函数被调用。 IE

struct A
{
  template<typename T>
  bool foo(T arg) { return true; }

  bool foo(int arg) { return false; }

  void bar()
  {
    bool test = foo(7);  // Returns false
  }
};

Answer 5

在 C++ 17 中，我使用“if constexpr”来避免专门化（和重写）我的方法。 例如：

template <size_t TSize>
struct A
{
    void recursiveMethod();
};

template <size_t TSize>
void A<TSize>::recursiveMethod()
{
    if constexpr (TSize == 1)
    {
        //[...] imple without subA
    }
    else
    {
        A<TSize - 1> subA;

        //[...] imple
    }
}

避免专门化 A<1>::recursiveMethod()。
您还可以将此方法用于类型，如下例所示：

template <typename T>
struct A
{
    void foo();
};

template <typename T>
void A<T>::foo()
{
    if constexpr (std::is_arithmetic_v<T>)
    {
        std::cout << "arithmetic" << std::endl;
    }
    else
    {
        std::cout << "other" << std::endl;
    }
}


int main()
{
    A<char*> a;
    a.foo();

    A<int> b;

    b.foo();
}

输出：

other
arithmetic