Compiling C++ when two classes refer to one another

Question

I am trying to write a simple wrapper around a connection pointer that will return it to the pool when the wrapper is destroyed, but it wont compile because the ConnectionPool and AutoConn need each other to be declared.

I tried to use forward deceleration but it didn't work. How do I solve this? (using 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);
    }
};

design wise this is a BAD idea, you should try to remove the circular dependancy! — NomeN, Mar 15 '10 at 13:29
well, it's a localized issue and the benefit of not having to worry about releasing the connection (in face of possible exceptions) far outweigh the "badness" of this design problem. — Omry Yadan, Mar 15 '10 at 13:32
possible duplicate of http://stackoverflow.com/questions/2233149/two-classes-and-inline-functions — , Mar 31 '10 at 15:15

score 6 · Accepted Answer · answered Mar 15 '10 at 13:23

A combination of forward declaration and separation of declaration from definition of members with circular dependencies works. For example:

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);
}

score 4 · Answer 2 · answered Mar 15 '10 at 13:18

4

Use forward declaration:

class Connection {};

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

class AutoConn {
//definitions
};

class ConnectionPool {
//definitions
};

answered Mar 15 '10 at 13:18

sharptooth

167,383
100
513
979

I suggest you try to compile it. it does not compile. – Omry Yadan Mar 15 '10 at 13:24

score 3 · Answer 3 · answered Mar 15 '10 at 13:18

3

implement the functions after the point where the classes are defined

answered Mar 15 '10 at 13:18

stefaanv

14,072
2
31
53

score 3 · Answer 4 · answered Mar 15 '10 at 13:19

3

The correct syntax for a forward declaration is:

class Connection; // no {}

If you write

class Connection {};

Then you are defining the class, and you can't define a class twice.

Also, shouldn't you be forward declaring AutoConn, not Connection?

answered Mar 15 '10 at 13:19

Peter Alexander

53,344
14
119
168

this is not forward deceleration, it's just a deceleration so the sample compiled. – Omry Yadan Mar 15 '10 at 13:25
He did not define it twice; that is the *only* definition of Connection. I am assuming it is just a place-holder to reduce the amount of posted code. – Clifford Mar 15 '10 at 13:25
Oh, I thought that was your attempt at the forward declaration - my apologies. – Peter Alexander Mar 15 '10 at 14:15

score 1 · Answer 5 · answered Mar 15 '10 at 13:22

Forward declaration only tells the compiler "such a class exists". In your

AutoConn getConn()

since AutoConn is a value type, the whole structure of AutoConn must be known, so forward declaration of the class won't work. So you must put the actual declaration of AutoConn before ConnectionPool.

In your AutoConn, the type ConnectionPool is only referred by pointers. In this case the whole structure of ConnectionPool is not required, so forward declaration of ConnectionPool is enough.

Therefore you need to rearrangement the classes into this:

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

But notice that

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

these methods require the compiler to know the members of ConnectionPool, so a complete structure is needed. To solve this problem the definition must be placed after ConnectionPool. Thus only the constructors and destructors should remain.

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

score 0 · Answer 6 · answered Mar 15 '10 at 13:18

0

You might want to outsource the definition of all ConnectionPool and AutoConn methods, i.e.

class ConnectionPool;
class AutoConn {…};

class ConnectionPool {…};

AutoConn ConnectionPool::getConn() {
   …
}

answered Mar 15 '10 at 13:18

Alexander Gessler

45,603
7
82
122

score 0 · Answer 7 · answered Mar 15 '10 at 13:20

0

Don't include ConnectionPool header file in AutoConn. Just use a forward reference like class ConnectionPool; in the AutoConn header file.

answered Mar 15 '10 at 13:20

Naveen

74,600
47
176
233

Compiling C++ when two classes refer to one another

7 Answers7