smart pointers, typedefs and forward declarations

Question

I love using smart pointers, and have seen a bit of code which makes nice use of typedefs make make them prettier. For example:

struct A {
    typedef boost::shared_ptr<A> pointer;
};

allows me to write: A::pointer a(new A);

But I have hit a minor snag in my typedef happiness :-/, forward declarations...

So imagine this scenario:

struct B;
struct A {
    boost::shared_ptr<B> b_;
};

struct B {
    boost::shared_ptr<A> a_;
};

works well enough, but I'd love to clean that up a little. Unfortunately, this is doesn't work

struct B;
struct A {
    typedef boost::shared_ptr<A> pointer;
    B::pointer b_; // <-- error here
};

struct B {
    typedef boost::shared_ptr<B> pointer;
    A::pointer a_;
};

I understand why, at that point in the file, the compiler has no information that B in fact has a type in it named pointer.

I have a feeling that I am stuck using the old approach at least for some stuff, but I'd love to hear some clever ideas.

Answer 1

That use of typedefs doesn't make it prettier- it's worthless. You can make a shared_ptr to an incomplete type, so just use shared_ptr<B>.

Answer 2

If you want to share typedefs you probably want to use namespaces for declaring them:

struct A;
struct B;

namespace Aimpl {
  typedef boost::shared_ptr<A> pointer;
}

namespace Bimpl {
  typedef boost::shared_ptr<B> pointer;
}

struct A {
    Bimpl::pointer b_;
};

struct B {
    Aimpl::pointer a_;
};