Déclaration directe de types/classes imbriqués en C++.

Question

J'ai récemment été coincé dans une situation comme celle-ci :

class A
{
public:
    typedef struct/class {...} B;
...
    C::D *someField;
}

class C
{
public:
    typedef struct/class {...} D;
...
    A::B *someField;
}

En général, vous pouvez déclarer un nom de classe :

class A;

Mais vous ne pouvez pas déclarer en avance un type imbriqué, ce qui suit provoque une erreur de compilation.

class C::D;

Des idées ?

Answer 1

Vous ne pouvez pas le faire, c'est un trou dans le langage C++. Vous devrez désimbriquer au moins une des classes imbriquées.

Answer 2

class IDontControl
{
    class Nested
    {
        Nested(int i);
    };
};

J'avais besoin d'une référence avant comme :

class IDontControl::Nested; // But this doesn't work.

Ma solution de rechange était :

class IDontControl_Nested; // Forward reference to distinct name.

Plus tard, quand je pourrais utiliser la définition complète :

#include <idontcontrol.h>

// I defined the forward ref like this:
class IDontControl_Nested : public IDontControl::Nested
{
    // Needed to make a forwarding constructor here
    IDontControl_Nested(int i) : Nested(i) { }
};

Cette technique poserait probablement plus de problèmes qu'elle n'en vaut la peine s'il y avait des constructeurs compliqués ou d'autres fonctions membres spéciales qui n'étaient pas héritées sans problème. Je pourrais imaginer que certains modèles magiques réagissent mal.

Mais dans mon cas très simple, cela semble fonctionner.

Answer 3

Si vous voulez vraiment éviter d'inclure le méchant fichier d'en-tête dans votre fichier d'en-tête, vous pouvez faire ceci :

hpp :

class MyClass
{
public:
    template<typename ThrowAway>
    void doesStuff();
};

fichier cpp

#include "MyClass.hpp"
#include "Annoying-3rd-party.hpp"

template<> void MyClass::doesStuff<This::Is::An::Embedded::Type>()
{
    // ...
}

Mais alors :

1. vous devrez spécifier le type embarqué au moment de l'appel (surtout si votre fonction ne prend pas de paramètres du type embarqué)
2. votre fonction ne peut pas être virtuelle (car c'est un template)

Alors, oui, des compromis...

Answer 4

Si vous avez accès à la modification du code source des classes C et D, vous pouvez alors sortir la classe D séparément, et entrer un synonyme de celle-ci dans la classe C :

class CD {

};

class C {
public:

    using D = CD;

};

class CD;

Answer 5

Je n'appellerais pas cela une réponse, mais néanmoins une découverte intéressante : Si vous répétez la déclaration de votre structure dans un espace de nom appelé C, tout va bien (dans gcc au moins). Lorsque la définition de la classe C est trouvée, elle semble écraser silencieusement l'espace de nom C.

namespace C {
    typedef struct {} D;
}

class A
{
public:
 typedef struct/class {...} B;
...
C::D *someField;
}

class C
{
public:
   typedef struct/class {...} D;
...
   A::B *someField;
}