C++: passando il puntatore a un'altra classe

Question

Sono nuovo al C++ ma ho una certa esperienza in Java. Durante la codifica, mi sono imbattuto in un errore che mi ha confuso. Ecco il mio codice (semplificato, ma gli errori sono gli stessi):

Ah:

#pragma once 
#include "B.h" 
class A 
{ 
public: 
    A(); 
    void foo(); 
    void sayHello(); 
    B b; 
}; 

A.cpp:

#include "A.h" 
#include <iostream>  
A::A() {} 
void A::foo() { 
    b.bar(this); 
} 
void A::sayHello() { 
    std::cout << "Hello" << std::endl; 
} 

Bh:

#pragma once 
#include "A.h" 
class B 
{ 
public: 
    B(); 
    void bar(A *a); 
}; 

B.cpp:

#include "B.h" 
B::B(){} 
void B::bar(A *a) { 
    a->sayHello(); 
} 

voglio passare un puntatore del un oggetto alla funzione bar in B, in modo che sarò in grado di modificare e accesso a campi in bar. Stranamente, ottengo questi errori quando chiamo foo attraverso un'istanza di Un da un'altra classe:

1>------ Build started: Project: Test, Configuration: Debug Win32 ------ 
1> main.cpp 
1>d:\stuff\visual studio 2015\projects\test\test\b.h(7): error C2061: syntax error: identifier 'A' 
1> B.cpp 
1>d:\stuff\visual studio 2015\projects\test\test\a.h(9): error C3646: 'b': unknown override specifier 
1>d:\stuff\visual studio 2015\projects\test\test\a.h(9): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int 
1> A.cpp 
1>d:\stuff\visual studio 2015\projects\test\test\b.h(7): error C2061: syntax error: identifier 'A' 
1>d:\stuff\visual studio 2015\projects\test\test\a.cpp(5): error C2660: 'B::bar': function does not take 1 arguments 
1> Generating Code... 
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ========== 

Il codice funziona bene se non includo Ah in Bh e io don non passare nulla alla funzione bar.

Ho provato a google cosa potrebbe causare questi errori ma non sono stato in grado di risolvere il problema da solo perché non capisco cosa causa questi errori. Che cosa sto facendo di sbagliato?

Answer 1

Nel file di intestazione di Ah, si dispone:

#include "B.h" 

Nel file di intestazione di Bh, si ha:

#include "A.h" 

Si hanno una circolare includere, se la definizione di A e B dipende l'uno dall'altro.

---

Una soluzione semplice è quella di utilizzare forward declaration in definizione di class B:

1. Sostituire la linea #include "A.h" nel file di B.h con class B;
2. Aggiungere #include "A.h" all'inizio del B.cpp

---

Avviso tuttavia, non è possibile utilizzare in avanti dichiarazione per class A, la ragione è che si dispone di un valore b di class B come variabile membro della class A:

#pragma once 
#include "B.h" 
class A 
{ 
public: 
    A(); 
    void foo(); 
    void sayHello(); 
    B b;    /// I mean this line here more specifically 
}; 

La necessità compilatore per conoscere la definizione di class B al fine di determinare la dimensione corretta per la classe A. Ecco perché è necessario inserire lo #include "B.h" all'inizio di A.h.

Answer 2

Entrambe le intestazioni si riferiscono l'una all'altra. Solo uno può essere effettivamente valutato prima dal compilatore e non è possibile risolvere il riferimento alla classe nell'altra intestazione. Non è ovvio dall'errore, ma il #pragma "una volta" sta facendo in modo che uno degli header non avvenga come previsto.

Se il file di intestazione B.h non ha bisogno di conoscere i dettagli di implementazione della classe A, che in questo caso non include, non includere il file A.h in B.h. Invece, modificare la dichiarazione di funzione di bar() per assomigliare a questo:

bar(class A *a); 

Il compilatore può costruire il codice da questa che passa un puntatore ad un oggetto A senza sapere nulla di ciò che è dentro di A. E doesn' Ho bisogno dell'intestazione Ah.

Quindi includere il file di intestazione A.h dopo il file di intestazione B.h in B.cpp.

Ho provato questo e funziona per me.

Answer 3

Diamo uno sguardo a B.cpp e guardare cosa succede con il include:

#include "B.h" 

B::B(){} 
void B::bar(A *a) { 
    a->sayHello(); 
} 

Con Bh incollato al posto del includono otteniamo:

#include "A.h" 

class B 
{ 
public: 
    B(); 
    void bar(A *a); 
}; 


B::B(){} 
void B::bar(A *a) { 
    a->sayHello(); 
} 

E poi mettendo in Ah luogo della sua includono:

#include "B.h" 
class A 
{ 
public: 
    A(); 
    void foo(); 
    void sayHello(); 
    B b; 
}; 

class B 
{ 
public: 
    B(); 
    void bar(A *a); 
}; 


B::B(){} 
void B::bar(A *a) { 
    a->sayHello(); 
} 

E qui ci fermiamo perché pragma once impedisce ri-in clusione di B.h

Possiamo vedere che nella classe A abbiamo la definizione B b;, ma la classe B non è ancora definita. Kaboom. A non può essere definito senza B e B non è ancora stato definito.

A devono avere la dimensione di B per soddisfare B b;, quindi richiede la definizione completa di B. B ha bisogno di sapere solo A esiste perché ha bisogno solo di un puntatore a A per soddisfare void bar(A *a);. Quindi ...

A.h

#pragma once 
#include "B.h" 
class A 
{ 
public: 
    A(); 
    void foo(); 
    void sayHello(); 
    B b; 
}; 

A.cpp

#include "A.h" 
#include <iostream>  
A::A() {} 
void A::foo() { 
    b.bar(this); 
} 
void A::sayHello() { 
    std::cout << "Hello" << std::endl; 
} 

B.h

#pragma once 

class A; // forward definition of class A 
class B 
{ 
public: 
    B(); 
    void bar(A *a); 
}; 

B.cpp

#include "A.h" 
B::B(){} 
void B::bar(A *a) { 
    a->sayHello(); 
} 

Answer 4

fare questi cambiamenti:

B.h : - Avanti dichiarare A

#pragma once 
// #include "A.h" 
class A; 
//^^^^^^ 

class B { 
public: 
    B(); 
    void bar(A *a); 
}; 

B.cpp: #include "A.h"

//#include "B.h" 
#include "A.h" 
//^^^^^^^^^^^^ 

B::B(){} 
void B::bar(A *a) { 
    a->sayHello(); 
} 

Questo è tutto.