Re: class that have a member of type that's derived from it

From:

Alan Johnson <alanwj@no.spam.stanford.edu>

Newsgroups:

comp.lang.c++

Date:

Thu, 20 Jul 2006 20:42:39 -0700

Message-ID:

<e9pifg$l58$1@news.Stanford.EDU>

Mirko Puhic wrote:

Alan Johnson wrote:

Mirko Puhic wrote:

Is there a way to properly do this?

struct Derived;

struct Base{
Derived der;
};

struct Derived: public Base{

};

This is called the Curiously Recurring Template Pattern (honestly).

template <typename DerivedType>
struct Base
{
DerivedType der ;
} ;

struct Derived : public Base<Derived>
{
} ;

Except, I should have run it through a compiler before posting. That
won't work. And object of type Derived can't contain a member
(directly or via inheritance) of type Derived, because that member
would, of course, also contain an member of type Derived, which would
also ... you see the problem.

What you CAN do is have a pointer or reference. Example:
struct Derived ;

template <typename DerivedType>
struct Base
{
DerivedType * der ;
} ;

struct Derived : public Base<Derived>
{
} ;

I see. Pointer will do. But in that case I think there's no need to use
a template:

struct Derived;

struct Base{

    Derived * der;

};

struct Derived: public Base{

};

True, though there are still times when that template pattern is useful.
  Consider if you wanted to make a utility from which people could
derive to make their class into a linked list node. It might be useful
to do something like:

template <typename T>
struct Linkable
{
   T * next ;
} ;

class MyType : public Linkable<MyType>
{
   // ...
} ;

Another case is when you need each derived type to have its own copy of
static members.

template <typename T>
struct Base
{
   // Note that this class doesn't actually use its template parameter.
   static SomeType value ;
} ;

// A::value and B::value are separate objects.
class A : public Base<A> {}
class B : public Base<B> {}

More exotic uses arise in various template metaprogramming techniques.

--
Alan Johnson