intrusive smart pointers and cyclic type dependencies

I have two classes A and B that are managed by intrusive smart pointers.
But A as well as B can contain managed references to the other class. So
the smart pointer must deal with incomplete types.

boost::intrusive_ptr can deal with that but it is inconvenient to define
the two helper functions for each type, especially in case of forward
declarations of a class.

Currently I tried the implementation below.
(No thread safety for simplification.)

First of all I am not sure if it has some undefined behavior because of
the incomplete type.
Furthermore I tried to do some optimization to access the reference
count inline if the type is no longer incomplete. Unfortunately the
trick did not work, because get_ref(T*) is still preferred over
get_ref(ref_count*) even if T is known to derive from ref_count. Is
there a way to avoid the real function call for complete types?
If so it could also be used for the call to delete_me by adding a class
ref_count_virt with a virtual destructor.

Marcel

--------------------
#include <stdio.h>
#include <assert.h>

#if (defined(__IBMC__) && __IBMC__ <= 300) || (defined(__IBMCPP__) &&
__IBMCPP__ <= 300)
#define bool signed char
#define true 1
#define false 0
#endif

#define DEBUGLOG(x) printf x

/* Interface to make a class reference countable */
class ref_count
{ friend unsigned& get_ref(ref_count*);
  private:
   unsigned Count;
  private: // non-copyable
   ref_count(const ref_count*);
   void operator=(const ref_count&);
  protected:
   ref_count() : Count(0) {}
   ~ref_count() {} // Must not call the non-virtual destructor directly.
  public:
   // Checks whether the object is currently unique.
   bool RefCountIsUnique() const;
   // Checks whether the object is not under control of a int_ptr.
   // This is the case when the object is just constructed and not yet
   // assigned to an int_ptr instance or if the object is about to be
   // deleted.
   bool RefCountIsUnmanaged() const;
};

inline unsigned& get_ref(ref_count* r)
{ return r->Count;
}

template <class T>
unsigned& get_ref(T* r);

template <class T>
void delete_me(T* ptr);

/* Intrusive reference counted smart pointer. */
template <class T>
class int_ptr
{private:
   T* Ptr;
  public:
   // Initialize a NULL pointer.
   int_ptr() : Ptr(NULL) {}
   // Store a object under reference count control.
   int_ptr(T* ptr) : Ptr(ptr) { if (Ptr) ++get_ref(Ptr); }
   // Copy constructor
   int_ptr(const int_ptr<T>& r) : Ptr(r.Ptr) { if (Ptr) ++get_ref(Ptr); }
   // Destructor, frees the stored object if this is the last reference.
   ~int_ptr() { if (Ptr && --get_ref(Ptr) == 0)
                                    delete_me(Ptr); }
   // Basic operators
   T* get() const { return Ptr; }
   operator T*() const { return Ptr; }
   T& operator*() const { assert(Ptr); return *Ptr; }
   T* operator->() const { assert(Ptr); return Ptr; }
   // assignment
   void assign(T* ptr);
   int_ptr<T>& operator=(T* ptr){ assign(ptr); return *this; }
   int_ptr<T>& operator=(const int_ptr<T>& r)
                                { assign(r.Ptr); return *this; }
   void swap(int_ptr<T>& r)
                              { T* tmp = Ptr; Ptr = r.Ptr; r.Ptr = tmp; }
};

template <class T>
void int_ptr<T>::assign(T* ptr)
{ if (ptr)
     ++get_ref(ptr);
   if (Ptr && --get_ref(Ptr) == 0)
     delete_me(Ptr);
   Ptr = ptr;
}

struct A;

struct B;

// Base class to force non-trivial pointer conversions.
struct C
{ const unsigned magic;
   C::C() : magic(0xc0c0c0c0) {}
};

struct A : public C, public ref_count
{ const unsigned magic;
   int_ptr<B> b;
   A() : magic(0xa0a0a0a0) { DEBUGLOG(("A(%p)::A()\n", this)); }
   ~A() { DEBUGLOG(("A(%p)::~A()\n", this)); }
};

struct B : public C, public ref_count
{ const unsigned magic;
   int_ptr<A> a;
   B() : magic(0xb0b0b0b0) { DEBUGLOG(("B(%p)::B()\n", this)); }
   ~B() { DEBUGLOG(("B(%p)::~B()\n", this)); }
};

int main()
{
   int_ptr<A> a = new A();
   int_ptr<B> b = new B();
   // Make cyclic dependency
   a->b = b;
   b->a = a;
   // Cancel cyclic dependency
   a->b = NULL;
   return 0;
}

// proxy for type safety
inline unsigned& get_ref_proxy(ref_count* r)
{ return get_ref(r);
}

template <class T>
unsigned& get_ref(T* r)
{ DEBUGLOG(("get_ref(T* %p)\n", r));
   return get_ref_proxy(r);
}

template <class T>
void delete_me(T* ptr)
{ delete ptr;
}