“non valide utilisation incomplète de type” erreur partielle de la spécialisation de modèle

Le code suivant:

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

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

me donne l'erreur

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

(Je suis en utilisant gcc.) Est ma syntaxe pour une partie de la spécialisation de mal? Notez que si je supprime le deuxième argument:

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

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

puis il compile correctement.

InformationsquelleAutor Jesse Beder | 2008-10-02
  1. 37

    Vous ne pouvez pas partiellement spécialiser une fonction. Si vous le souhaitez sur une fonction membre, vous devez partiellement spécialiser l'ensemble du modèle (oui, c'est énervant). Sur une grande basé sur un modèle de classe, partiellement spécialiser une fonction, vous avez besoin d'une solution de contournement. Peut-être basé sur un modèle membre de la structure (par exemple,template <typename U = T> struct Nested) serait de travailler. Sinon, vous pouvez essayer de dériver à partir d'un autre modèle que partiellement spécialisé (travaux si vous utilisez le this->member notation, sinon vous rencontrerez des erreurs du compilateur).

    InformationsquelleAutor coppro
  2. 7

    Bien que coppro mentionné deux solutions déjà et Anonyme, a expliqué le deuxième, il m'a fallu un certain temps pour comprendre la première. Peut-être que le code suivant est utile pour quelqu'un de tomber sur ce site, qui continue à dominer le classement élevé dans google, comme moi. L'exemple (passage d'un vecteur/matrice/unique élément de numericalT comme dataT et puis accède à partir de [] ou directement) est bien sûr un peu artificiel, mais doivent illustrer comment vous pouvez réellement très proches partiellement spécialisé d'une fonction membre en l'enveloppant dans une partie de classe spécialisée. 

    /* 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) ...
};
    InformationsquelleAutor Echsecutor
  3. 3

    Si vous avez besoin de spécialiser partiellement un constructeur, vous pouvez essayer quelque chose comme:

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

    Note: ceci a été anonymisées à partir de quelque chose que je suis en train de travailler sur. Vous pouvez également utiliser cette option lorsque vous avez un modèle de classe avec beaucoup, beaucoup de membres et vous voulez juste ajouter une fonction.

    InformationsquelleAutor Anonymous Coward