C++: How to use types that have not been defined?

Question

C++ requires all types to be defined before they can be used, which makes it important to include header files in the right order. Fine. But what about my situation:

Bunny.h:

   class Bunny
   {
       ...
   private:
       Reference<Bunny> parent;
   }

The compiler complains, because technically Bunny has not been completely defined at the point where I use it in its own class definition. because I did something stupid (unrelated).

Apart from re-writing my template class Reference so it takes a pointer type (in which case I can use the forward declaration of Bunny), I don't know how to solve this.

Any suggestions?

EDIT: My Reference class (XObject is a base class for data mode objects):

template <class T = XObject> class Reference
{
public:
    Reference() : m_ptr (NULL) {}
    Reference(T* p)
    {
        m_ptr = p;
        if (p != NULL) ((XObject*)p)->ref();
    }
    ~Reference()
    {
        if (m_ptr)
        {
            ((XObject*)m_ptr)->deref();
        }
    }

    // ... assignment, comparison, etc.

private:
    T* m_ptr;
}; 

EDIT: This works fine, the problem was something else. Thanks so much for your help!

Answer 1

If Reference<T> has a variable of type T, then T cannot have a variable of type Reference<T>. Your alternatives are either rewriting Reference<T>, or rewriting Bunny to use a pointer to Reference<T>:

template<class> class Reference;

class Bunny
{
    ...
private:
    Reference<Bunny>* parent;
}

Answer 2

The answer to your question depends on what Reference<> looks like. If it has an instance variable of type Bunny in it then of course it won't work (how would it, you have a recursive definition that never ends). If it has only references and pointers in it then it should work fine. The Bunny type in the template instantiation would not interfere with this.

Edit (post reference<> code edit):

I can't seem to recreate your problem. I've reimplemented code like what you're doing but it compiles fine for me:

struct base {
  void fun() {}
};
template < typename T >
struct temp
{
  T * t;

  void f() { ((base*)t)->fun(); }
};

struct test
{
  temp<test> t;

};

int main()
{
  test t;
  t.t.f();
}

It's obviously invalid code in that you're going to get undefined results but it does compile. Mainly the issue here is the reinterpret cast from type test* to type base*. If test really did inherit from base then the cast wouldn't even be necessary. Code like this will not function as expected but it should compile just fine. One recommendation I'd have is to lose all the c-style casts. That won't solve the problem you're having though, whatever it is...it's got to be somewhere in the code you're not pasting.

Answer 3

Isn't this merely a matter of abstraction, where abstraction becomes the solution to the problem? I'd consider creating an interface, IBunny, and then use Reference<IBunny> inside any definition that implements IBunny.

This is one of those use-cases that interfaces were invented for (comes in handy in typical GoF creational patterns).