Ошибка "недопустимое использование неполного типа" с частичной специализацией шаблона

Вы не можете частично специализировать функцию. Если вы хотите сделать это для функции-члена, вы должны частично специализировать весь шаблон (да, это раздражает). В большом шаблонном классе для частичной специализации функции может потребоваться обходной путь. Возможно, будет работать шаблонная структура члена (например, template <typename U = T> struct Nested). Или вы можете попробовать получить из другого шаблона, который частично специализируется (работает, если вы используете нотацию this->member, иначе вы столкнетесь с ошибками компилятора).

Если вам нужно частично специализировать конструктор, вы можете попробовать что-то вроде:

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

Примечание: это было анонимно из того, над чем я работаю. Вы также можете использовать это, когда у вас есть класс шаблона с большим количеством членов, и вы просто хотите добавить функцию.

Хотя coppro уже упомянул два решения, а Anonymous объяснил второе, мне потребовалось некоторое время, чтобы понять первое. Возможно, следующий код будет полезен тем, кто наткнулся на этот сайт, который, как и я, по-прежнему занимает высокие позиции в Google. Пример (передача вектора / массива / отдельного элемента числового T как 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) ...
};

Если вы читаете этот вопрос, возможно, вам стоит напомнить, что, хотя вы не можете частично специализировать методы, вы можете добавить не шаблонную перегрузку, которая будет вызываться вместо шаблонной функции. т.е.

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

В 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