Errore "X non nomina un tipo" in C ++

Ho due classi dichiarate come di seguito:

class User
{
public:
  MyMessageBox dataMsgBox;
};

class MyMessageBox
{
public:
  void sendMessage(Message *msg, User *recvr);
  Message receiveMessage();
  vector<Message> *dataMessageList;
};

Quando provo a compilarlo usando gcc, dà il seguente errore:

MyMessageBox non nomina un tipo

Quando il compilatore compila la classe Usere arriva alla MyMessageBoxriga, MyMessageBoxnon è stato ancora definito. Il compilatore non ha idea che MyMessageBoxesista, quindi non può capire il significato del membro della classe.

Devi assicurarti che MyMessageBoxsia definito prima di usarlo come membro. Questo viene risolto invertendo l'ordine di definizione. Tuttavia, hai una dipendenza ciclica: se ti sposti MyMessageBoxsopra User, allora nella definizione del MyMessageBoxnome Usernon verrà definito!

Quello che puoi fare è dichiarare in avanti User ; cioè dichiaralo ma non definirlo. Durante la compilazione, un tipo dichiarato ma non definito viene chiamato tipo incompleto . Considera l'esempio più semplice:

struct foo; // foo is *declared* to be a struct, but that struct is not yet defined

struct bar
{
    // this is okay, it's just a pointer;
    // we can point to something without knowing how that something is defined
    foo* fp; 

    // likewise, we can form a reference to it
    void some_func(foo& fr);

    // but this would be an error, as before, because it requires a definition
    /* foo fooMember; */
};

struct foo // okay, now define foo!
{
    int fooInt;
    double fooDouble;
};

void bar::some_func(foo& fr)
{
    // now that foo is defined, we can read that reference:
    fr.fooInt = 111605;
    fr.foDouble = 123.456;
}

Con la dichiarazione in avanti User, MyMessageBoxpuò ancora formare un puntatore o un riferimento ad esso:

class User; // let the compiler know such a class will be defined

class MyMessageBox
{
public:
    // this is ok, no definitions needed yet for User (or Message)
    void sendMessage(Message *msg, User *recvr); 

    Message receiveMessage();
    vector<Message>* dataMessageList;
};

class User
{
public:
    // also ok, since it's now defined
    MyMessageBox dataMsgBox;
};

Non puoi farlo al contrario: come accennato, un membro della classe deve avere una definizione. (Il motivo è che il compilatore ha bisogno di sapere quanta memoria Useroccupa e di sapere che ha bisogno di conoscere la dimensione dei suoi membri.) Se dovessi dire:

class MyMessageBox;

class User
{
public:
    // size not available! it's an incomplete type
    MyMessageBox dataMsgBox;
};

Non funzionerebbe, poiché non conosce ancora le dimensioni.

In una nota a margine, questa funzione:

 void sendMessage(Message *msg, User *recvr);

Probabilmente non dovrebbe prendere nessuno di questi per puntatore. Non puoi inviare un messaggio senza un messaggio, né puoi inviare un messaggio senza un utente a cui inviarlo. Ed entrambe queste situazioni sono esprimibili passando null come argomento a entrambi i parametri (null è un valore puntatore perfettamente valido!)

Piuttosto, usa un riferimento (possibilmente const):

 void sendMessage(const Message& msg, User& recvr);

1. Inoltra dichiara utente
2. Metti la dichiarazione di MyMessageBox prima di User

I compilatori C ++ elaborano il loro input una volta. Ogni classe che utilizzi deve essere stata definita per prima. Lo usi MyMessageBoxprima di definirlo. In questo caso, puoi semplicemente scambiare le due definizioni di classe.

È necessario definire MyMessageBox prima di User - perché l'utente include l'oggetto di MyMessageBox per valore (e quindi il compilatore dovrebbe conoscerne le dimensioni).

Inoltre dovrai inoltrare la dichiarazione dell'utente prima di MyMessageBox, perché MyMessageBox include membri di tipo User *.

In una nota correlata, se avessi:

    class User; // let the compiler know such a class will be defined

    class MyMessageBox
    {
    public:
        User* myUser;
    };

    class User
    {
    public:
        // also ok, since it's now defined
        MyMessageBox dataMsgBox;
    };

Allora funzionerebbe anche, perché l'utente è definito in MyMessageBox come un puntatore

È necessario dichiarare il prototipo prima di utilizzarlo:

class User;

class MyMessageBox
{
public:
 void sendMessage(Message *msg, User *recvr);
 Message receiveMessage();
 vector<Message> *dataMessageList;
};

class User
{
public:
 MyMessageBox dataMsgBox;
};

modifica : scambiati i tipi

È sempre incoraggiato in C ++ avere una classe per file di intestazione, vedere questa discussione in SO [ 1 ]. La risposta di GManNickG spiega perché ciò è accaduto. Ma il modo migliore per risolvere questo problema è mettere la Userclasse in un file di intestazione ( User.h) e la MyMessageBoxclasse in un altro file di intestazione ( MyMessageBox.h). Quindi nel tuo User.hincludi MyMessageBox.he nel MyMessageBox.hincludi User.h. Non dimenticare "include gaurds" [ 2 ] in modo che il tuo codice venga compilato correttamente.