Kompilieren von C++, wenn zwei Klassen aufeinander verweisen

Question

Ich versuche, einen einfachen Wrapper um einen Verbindungszeiger zu schreiben, der ihn an den Pool zurückgibt, wenn der Wrapper zerstört wird, aber nicht kompiliert, da ConnectionPool und AutoConn sich gegenseitig benötigen erklärt werden.

Ich versuchte, Vorwärtsverzögerung zu verwenden, aber es hat nicht funktioniert. Wie löse ich das? (Mit g ++)

class Connection {}; 

class ConnectionPool 
{ 
    Connection *m_c; 
public: 
    AutoConn getConn() 
    { 
     return AutoConn(this, m_c); // by value 
    } 

    void releaseConnection(Connection *c) 
    { 
    } 
}; 

class AutoConn 
{ 
    ConnectionPool* m_pool; 
    Connection *m_connection; 
public: 
    AutoConn(ConnectionPool* pool, Connection *c) : m_pool(pool), m_connection(c) {} 
    ~AutoConn() 
    { 
     m_pool->releaseConnection(m_connection); 
    } 
}; 

Answer 1

Eine Kombination von Vorwärtsdeklaration und Trennung der Deklaration von der Definition von Mitgliedern mit zirkulären Abhängigkeiten funktioniert. Zum Beispiel:

class Connection {}; 
class ConnectionPool ; 

class AutoConn 
{ 

    ConnectionPool* m_pool; 
    Connection *m_connection; 
public: 
    AutoConn(ConnectionPool* pool, Connection *c) : m_pool(pool), m_connection(c) {} 
    ~AutoConn() ; // Not defined here because it accesses unknown members of class Connection 
} ; 

class ConnectionPool 
{ 
    Connection *m_c; 
public: 
    AutoConn getConn() 
    { 
     return AutoConn(this, m_c); // by value 
    } 

    void releaseConnection(Connection *c) 
    { 
    } 
}; 

// Definition of destructor with class Connection member dependencies. 
AutoConn::~AutoConn() 
{ 
    m_pool->releaseConnection(m_connection); 
} 

Answer 2

Sie mit der Vorwärts-Deklaration:

class Connection {}; 

class ConnectionPool; //<<<<<<<<<<<<<<<forward declaration 

class AutoConn { 
//definitions 
}; 

class ConnectionPool { 
//definitions 
}; 

Answer 3

die Funktionen nach dem Punkt implementieren, wo die Klassen definiert sind

Answer 4

Sie möchten vielleicht die Definition aller ConnectionPool und AutoConn Methoden zur Auslagerung , dh

class ConnectionPool; 
class AutoConn {…}; 

class ConnectionPool {…}; 

AutoConn ConnectionPool::getConn() { 
    … 
} 

Answer 5

Die co rrect Syntax für eine Vorwärtsdeklaration ist:

class Connection; // no {} 

Wenn Sie schreiben

class Connection {}; 

Dann Sie die Klasse definieren, und Sie können eine Klasse zweimal nicht definieren.

Auch sollten Sie nicht vorwärts sein, AutoConn, nicht Connection deklarieren?

Answer 6

Nicht enthalten ConnectionPool Header-Datei in AutoConn. Verwenden Sie einfach eine Vorwärtsreferenz wie class ConnectionPool; in der AutoConn Header-Datei.

Answer 7

Vorwärtsdeklaration sagt nur dem Compiler "solch eine Klasse existiert". In Ihrem

AutoConn getConn() 

seit AutoConn ein Werttyp ist, die gesamte Struktur der AutoConn bekannt sein müssen, so Vorwärtsdeklaration der Klasse wird nicht funktionieren. Sie müssen also die tatsächliche Deklaration von AutoConn vor ConnectionPool setzen.

In Ihrer AutoConn wird der Typ ConnectionPool nur durch Zeiger verwiesen. In diesem Fall ist die gesamte Struktur von ConnectionPool nicht erforderlich, daher reicht die Vorwärtsdeklaration von ConnectionPool aus.

Deshalb müssen Sie die Klassen in diese Umlagerung:

class Connection; 
class ConnectionPool; 
class AutoConn { ... }; 
class ConnectionPool { ... }; 

aber feststellen, dass

AutoConn(ConnectionPool* pool, Connection *c) : m_pool(pool), m_connection(c) {} 
~AutoConn() 
{ 
    m_pool->releaseConnection(m_connection); 
} 

diese Methoden den Compiler erfordern die Mitglieder ConnectionPool zu wissen, so dass eine komplette Struktur benötigt wird. Um dieses Problem zu lösen, muss die Definition nach ConnectionPool platziert werden. Daher sollten nur die Konstruktoren und Destruktoren bleiben.

class AutoConn { 
    ... 
    AutoConn(ConnectionPool* pool, Connection *c); 
    ~AutoConn(); 
} 
class ConnectionPool { ... }; 
AutoConn::AutoConn(ConnectionPool* pool, Connection *c) : ... { ... } 
AutoConn::~AutoConn() { ... }