दो कक्षाएं एक दूसरे से संदर्भित करती हैं

Question

मैं एक कनेक्शन सूचक के चारों ओर एक साधारण रैपर लिखने की कोशिश कर रहा हूं जो रैपर नष्ट होने पर इसे पूल में वापस कर देगा, लेकिन यह संकलित नहीं होगा क्योंकि कनेक्शनपूल और ऑटोकॉन को एक दूसरे की आवश्यकता है घोषित किया जाना

मैंने आगे मंदी का उपयोग करने की कोशिश की लेकिन यह काम नहीं किया। मैं इसे कैसे हल करूं? (छ का उपयोग कर ++) आगे घोषणा

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

सर्कुलर निर्भरता कार्यों वाले सदस्यों की परिभाषा से आगे की घोषणा और घोषणा के पृथक्करण का एक संयोजन। उदाहरण के लिए:

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

उपयोग:

class Connection {}; 

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

class AutoConn { 
//definitions 
}; 

class ConnectionPool { 
//definitions 
}; 

Answer 3

बिंदु है जहां कक्षाएं

Answer 4

परिभाषित कर रहे हैं के बाद कार्यों को लागू आप सभी ConnectionPool और AutoConn तरीकों की परिभाषा आउटसोर्स करने के लिए चाहते हो सकता है , यानी

class ConnectionPool; 
class AutoConn {…}; 

class ConnectionPool {…}; 

AutoConn ConnectionPool::getConn() { 
    … 
} 

Answer 5

सह एक आगे घोषणा के लिए rrect वाक्य रचना है:

class Connection; // no {} 

आप लिखते हैं तो

class Connection {}; 

तो फिर तुम वर्ग को परिभाषित कर रहे हैं, और आप एक वर्ग में दो बार परिभाषित नहीं कर सकते हैं।

इसके अलावा, क्या आपको AutoConn घोषित नहीं करना चाहिए, Connection नहीं?

Answer 6

में ConnectionPool हेडर फ़ाइल शामिल न करें। AutoConn हेडर फ़ाइल में class ConnectionPool; जैसे आगे के संदर्भ का उपयोग करें।

Answer 7

आगे की घोषणा केवल संकलक को बताती है "ऐसी कक्षा मौजूद है"। अपने

AutoConn getConn() 

AutoConn के बाद में एक मान प्रकार, AutoConn की पूरी संरचना पता होना चाहिए, ताकि वर्ग के आगे घोषणा से काम नहीं चलेगा है। तो आपको ConnectionPool से पहले AutoConn की वास्तविक घोषणा करना होगा।

आपके AutoConn में, प्रकार ConnectionPool केवल पॉइंटर्स द्वारा संदर्भित किया जाता है। इस मामले में ConnectionPool की पूरी संरचना आवश्यक नहीं है, इसलिए आगे ConnectionPool की घोषणा पर्याप्त है।

इसलिए आप इस में कक्षाएं पुनर्व्यवस्था की जरूरत है:

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

लेकिन ध्यान दें कि

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

इन तरीकों संकलक की आवश्यकता होती है ConnectionPool के सदस्यों को पता है, तो एक पूरी संरचना की जरूरत है। इस समस्या को हल करने के लिए परिभाषा ConnectionPool के बाद रखी जानी चाहिए। इस प्रकार केवल रचनाकार और विनाशक बने रहना चाहिए।

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