utilisation invalide de type incomplète

Je suis en train d'utiliser un typedef, à partir d'une sous-classe dans mon projet, j'ai isolé mon problème dans l'exemple ci-dessous.

Personne ne sait où je vais mal?

template<typename Subclass>
class A {
    public:
        //Why doesn't it like this?
        void action(typename Subclass::mytype var) {
            (static_cast<Subclass*>(this))->do_action(var);
        }
};

class B : public A<B> {
    public:
        typedef int mytype;

        B() {}

        void do_action(mytype var) {
            //Do stuff
        }
};

int main(int argc, char** argv) {
    B myInstance;
    return 0;
}

C'est le résultat que j'obtiens:

sean@SEAN-PC:~/Documents/LucadeStudios/experiments$ g++ -o test test.cpp
test.cpp: In instantiation of ‘A<B>’:
test.cpp:10:   instantiated from here
test.cpp:5: error: invalid use of incomplete type ‘class B’
test.cpp:10: error: forward declaration of ‘class B’
InformationsquelleAutor seanhodges | 2009-03-16
  1. 63

    La raison en est que lors de l'instanciation d'un modèle de classe, tous ses déclarations (pas les définitions) de ses fonctions de membre sont instanciés trop. Le modèle de classe est instanciée précisément lors de la définition complète d'une spécialisation est nécessaire. C'est le cas lorsqu'elle est utilisée comme classe de base par exemple, comme dans votre cas.

    Ce qui se passe est que A<B> est instancié à 

    class B : public A<B>

    à quel point B n'est pas complète type encore (c'est après l'accolade fermante de la définition de la classe). Cependant, A<B>::actions'déclaration de B pour être complet, parce qu'il est en train de ramper dans le champ d'application de celui-ci:

    Subclass::mytype

    Ce que vous devez faire est de retarder l'instanciation à un certain point à qui B est terminée. Une façon de le faire est de modifier la déclaration de action à en faire un membre de modèle.

    template<typename T>
void action(T var) {
    (static_cast<Subclass*>(this))->do_action(var);
}

    Il est toujours de type-safe, car si var n'est pas du bon type, en passant var à do_action échouera.

    • J'ai réglé pour une légère restructuration de mon code (en raison de certaines autres questions connexes que je n'ai pas de décrire ici) mais j'ai testé cette approche, et elle n'a en effet de résoudre le problème. Merci!
    InformationsquelleAutor Johannes Schaub - litb
  2. 24

    Vous pouvez contourner ce problème en utilisant une classe de traits:

    Elle nécessite de définir un specialsed classe de traits pour chaque actuall classe que vous l'utilisez.

    template<typename SubClass>
class SubClass_traits
{};

template<typename Subclass>
class A {
    public:
        void action(typename SubClass_traits<Subclass>::mytype var)
        {
                (static_cast<Subclass*>(this))->do_action(var);
        }
};


//Definitions for B
class B;   //Forward declare

template<> //Define traits for B. So other classes can use it.
class SubClass_traits<B>
{
    public:
        typedef int mytype;
};

//Define B
class B : public A<B>
{
    //Define mytype in terms of the traits type.
    typedef SubClass_traits<B>::mytype  mytype;
    public:

        B() {}

        void do_action(mytype var) {
                //Do stuff
        }
};

int main(int argc, char** argv)
{
    B myInstance;
    return 0;
}
    InformationsquelleAutor Martin York
  3. 2

    Vous dérivez B de A<B>, donc la première chose que le compilateur ne, une fois qu'il voit la définition de la classe B est d'essayer d'instancier A<B>. Pour ce faire, il doit connus B::mytype pour le paramètre de action. Mais depuis que le compilateur est juste dans le processus de trouver la définition de la B, il ne sait pas ce type encore et vous obtiendrez une erreur.

    Un moyen de contourner cela est de déclarer le type de paramètre comme un autre paramètre du modèle, au lieu de l'intérieur de la classe dérivée:

    template<typename Subclass, typename Param>
class A {
    public:
        void action(Param var) {
                (static_cast<Subclass*>(this))->do_action(var);
        }
};

class B : public A<B, int> { ... };
    InformationsquelleAutor sth
  4. 1

    Pas exactement ce que vous demandez, mais vous pouvez rendre l'action d'un modèle de fonction de membre:

    template<typename Subclass>
class A {
    public:
        //Why doesn't it like this?
        template<class V> void action(V var) {
                (static_cast<Subclass*>(this))->do_action();
        }
};

class B : public A<B> {
    public:
        typedef int mytype;

        B() {}

        void do_action(mytype var) {
                //Do stuff
        }
};

int main(int argc, char** argv) {
    B myInstance;
    return 0;
}
    InformationsquelleAutor John Dibling
  5. 0

    Vous avez besoin d'utiliser un pointeur ou une référence sur le type n'est pas connu à cette époque, le compilateur ne peut pas instancier.

    Au lieu d'essayer:

    void action(const typename Subclass::mytype &var) {
            (static_cast<Subclass*>(this))->do_action();
    }
    • J'ai essayé de le changer pour une référence, puis un pointeur, et l'erreur est toujours la même. Je comprends votre point de si.
    InformationsquelleAutor Andreas Magnusson