quirky inheritance in c++

Wrap your head around this one:


template <typename T> class B { /*...*/ }

class A : public B<A> { /*...*/ }

Can anyone explain to me how the compiler manages to get this right?  (and it does, somehow)  Keep in mind the following:  Save for access restrictions, the class B<A> knows about any and all of A's constructors and static member functions.  At the same time, class A knows about any and all members of B<A>.

Doesn't the compiler have to compile the base class before compiling the derived?  That means compiling B<A> before A, but with the way templates work you have to compile A before B<A>.

try this:
template <class T>
class B {
private:
    T mT;
};

class A: public B<A> {};

>>1

You're referring to Coplien's curiosly recurring template pattern.  (http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern)

It's important to note that the base class is not intended to be used independently.  Because of this (as you can see in the linked wiki), you actually refer to the members of A by statically casting "this" to an A*, not by including an instance of A as a field.

Use a language that does not require templates.

Bringing /prog/ back to its people
All work and no play makes Jack a dull boy
All work and no play makes Jack a dull boy
All work and no play makes Jack a dull boy
All work and no play makes Jack a dull boy
All work and no play makes Jack a dull boy
All work and no play makes Jack a dull boy
All work and no play makes Jack a dull boy