Avant la déclaration d'imbrication des types/classes en C++

J'ai récemment obtenu coincé dans une situation comme ceci:

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

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

Habituellement, vous pouvez déclarer un nom de classe:

class A;

Mais vous ne pouvez pas déclarer avant un type imbriqué, les causes suivantes erreur de compilation.

class C::D;

Des idées?

Pourquoi avez-vous besoin? Notez que vous pouvez déclarer avant si c'est un membre de la même classe étant définie: class X { classe Y; Y *a; }; la classe X::Y { };
Fascinant d'erreur.
Cette solution a fonctionné pour moi (espace de noms C { classe D; };): stackoverflow.com/questions/22389784/...
J'ai trouvé une solution lien

InformationsquelleAutor Calmarius | 2009-06-04

c++class forward-declaration nested

210

Vous ne pouvez pas le faire, c'est un trou dans le langage C++. Vous aurez à onu-nid d'au moins une des classes imbriquées.
- Merci pour la réponse. Dans mon cas, ils ne sont pas mes classes imbriquées. J'ai été dans l'espoir d'éviter une énorme bibliothèque de fichier d'en-tête de dépendance avec un peu de référence vers l'avant. Je me demande si C++11, il fixe?
- Oh. Juste ce que je ne voulais pas google de montrer. Merci quand même pour la réponse concise.
- Même ici ... quelqu'un sait - pourquoi il n'est pas possible ? Il semble qu'il est valable de cas d'utilisation, et cette absence empêche l'architecture de cohérence dans certaines situations.
- Vous pouvez utiliser ami. Et il suffit de mettre un commentaire que vous l'utilisez pour contourner le trou du C++.
- Chaque fois que je rencontre une telle inutile de défauts dans cet ersatz de langue, je suis déchiré entre le rire et les larmes
InformationsquelleAutor Adam Rosenfield
31
```
class IDontControl
{
    class Nested
    {
        Nested(int i);
    };
};
```
J'avais besoin d'une référence vers l'avant comme:
```
class IDontControl::Nested; //But this doesn't work.
```
Ma solution est:
```
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 serait probablement plus d'ennuis que cela vaut la peine si il y avait compliqué les constructeurs ou les autres fonctions membres qui n'ont pas hérité de la douceur. Je ne pouvais imaginer un certain nombre de modèles de la magie réagit mal.

Mais dans mon cas très simple, il semble fonctionner.
- En C++11, vous pouvez hériter constructeurs par using basename::basename; dans la classe dérivée, donc pas de problème avec compliqué ctors.
- Tour de Nice, mais il ne fonctionnera pas si le pointeur de IDontControl::Niché utilisé à l'intérieur même de l'en-tête (où il déclaré avant) et est accessible à partir d'un code externe, qui comprend également la définition complète de IDontControl. (Parce que le compilateur ne peut pas correspondre à IDontControl_Nested et IDontControl::Imbriquée). Solution de contournement consiste à effectuer statique de la fonte.
- Je recommanderais de faire l'inverse et d'avoir la classe à l'extérieur, et il suffit d'utiliser typedef à l'intérieur de la classe
InformationsquelleAutor Marsh Ray
3

Si vous voulez vraiment éviter #, y compris le méchant fichier d'en-tête dans votre fichier d'en-tête, vous pourriez faire ceci:

php fichier:
```
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 embarqués de type lors de l'appel de temps (surtout si votre fonction ne prend aucun paramètre de l'option type)
2. votre fonction ne peut pas être virtuel (parce que c'est un modèle)
Donc, oui, les compromis...
- Ce que le diable est un hpp fichier?
- lol, un .hpp fichier d'en-tête est utilisé dans les projets C++ pour le distinguer d'un fichier en-tête C qui se termine généralement avec .h. Lorsque vous travaillez avec C++ et C dans le même projet, certaines personnes préfèrent .hpp et .rpc pour les fichiers C++, pour le faire explicitement avec ce type de fichiers de leur affaire, et .h et .c pour C fichiers.
InformationsquelleAutor edenbridge

Cela peut être fait par déclarer avant que l'extérieur de la classe comme un espace de noms.

De l'échantillon: Nous devons utiliser une classe imbriquée autres::A::niché dans others_a.h, qui est hors de notre contrôle.

others_a.h

namespace others {
struct A {
    struct Nested {
        Nested(int i) :i(i) {}
        int i{};
        void print() const { std::cout << i << std::endl; }
    };
};
}

my_class.h

#ifndef MY_CLASS_CPP
//A is actually a class
namespace others { namespace A { class Nested; } }
#endif

class MyClass {
public:
    MyClass(int i);
    ~MyClass();
    void print() const;
private:
    std::unique_ptr<others::A::Nested> _aNested;
};

my_class.cpp

#include "others_a.h"
#define MY_CLASS_CPP //Must before include my_class.h
#include "my_class.h"

MyClass::MyClass(int i) :
    _aNested(std::make_unique<others::A::Nested>(i)) {}
MyClass::~MyClass() {}
void MyClass::print() const {
    _aNested->print();
}

Ça peut fonctionner, mais il est sans-papiers. La raison pour laquelle cela fonctionne est que a::b est mutilé de la même manière, peu importe si a est de la classe ou de l'espace.
Ne fonctionne pas avec Clang ou GCC. Il est dit que l'extérieur de la classe a été déclarée comme quelque chose de différent que d'un espace de noms.

InformationsquelleAutor bitlixi

0

Je n'appellerais pas cela une réponse, mais néanmoins intéressant de trouver:
Si vous répétez la déclaration de votre structure dans un espace de noms appelé C, tout va bien (dans gcc au moins).
Lors de la définition de classe de C est trouvé, il semble silencieusement remplacer le namspace 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;
}
```
- J'ai essayé cela avec cygwin gcc et il ne se compile pas, si vous essayez de référence A. someField. C::D dans la classe d'Une définition fait référence à l' (vide) structure dans l'espace de noms, pas de la structure dans la classe C (BTW, ce n'est pas compilé dans MSVC)
- Il donne l'erreur: ""classe C" redéclarées comme autre type de symbole"
- Ressemble à un bug de GCC. Il semble réfléchir un nom d'espace de noms peut en cacher un nom de classe dans la même portée.
InformationsquelleAutor nschmidt

Ce serait une solution (au moins pour le problème décrit dans la question, pas pour le problème réel, c'est à dire, quand ne pas avoir le contrôle sur la définition de C):

class C_base {
public:
    class D { }; //definition of C::D
    //can also just be forward declared, if it needs members of A or A::B
};
class A {
public:
    class B { };
    C_base::D *someField; //need to call it C_base::D here
};
class C : public C_base { //inherits C_base::D
public:
    //Danger: Do not redeclare class D here!!
    //Depending on your compiler flags, you may not even get a warning
    //class D { };
    A::B *someField;
};

int main() {
    A a;
    C::D * test = a.someField; //here it can be called C::D
}

InformationsquelleAutor chtz

0

Si vous avez la possibilité de modifier le code source des classes C et D, alors vous pouvez prendre de la classe D séparément, et entrez un synonyme pour elle de classe C:
```
class CD {

};

class C {
public:

    using D = CD;

};

class CD;
```
InformationsquelleAutor Suvorov Ivan

Vous devez vous connecter pour publier un commentaire.