self-referencing policies

[jakevdp]

Hello,
I've just discovered policy based design (due to a forum topic a few days ago) and am having fun playing around with it. Here's a little question I ran into: I want my policy class to have a convenient label for the datatype inherent to its derived class. Here's my bare-bones example:

template<class T>
class policy{
public:
  typedef typename T::fooType fooType;
};

template<class fooType>
class foo : public policy<foo<fooType> >{
};

int main(){
  foo<int> F;
  return 0;
}

This doesn't compile (gcc v4.1), because at the time the typedef is evaluated by the compiler, foo is not yet fully defined. Any ideas how to get around this? I know I could nix the typedef and use T::fooType explicitly, but that gets very messy in my "real world" example...

[Peter_APIIT]

I think forward declaration may off the compile error.

[Russco]

Did you expect it to compile?

The compiler is looking for int::fooType and theres no such animal.

[jakevdp]

okay, how about this variation? I still get an error on compilation. I tried various combinations of predeclaring each class, but they don't seem to do the trick.

template<class T>
class policy{
public:
  typedef typename T::fooType fooType;
};

template<class T>
class foo : public policy<foo<T> >{
  typedef T fooType;
};


int main(){
  foo<int> F;
  return 0;
}

[0xC0000005]

Read Russco's comment again.

[Hermit]

okay, how about this variation? I still get an error on compilation. I tried various combinations of predeclaring each class, but they don't seem to do the trick.

template<class T>
class policy{
public:
  typedef typename T::fooType fooType;
};

template<class T>
class foo : public policy<foo<T> >{
  typedef T fooType;
};


int main(){
  foo<int> F;
  return 0;
}

This still doesn't make any sense. In order for the policy class to resolve T::fooType, T needs to be a complete type, which it can't be because at this point in the instantiation we're still evaluating its base class. This is the stuff "internal compiler error"s are made of.

Why not just do the following:

template<class T>
class policy{
public:
  typedef T fooType;
};

template<class T>
class foo : public policy<T>{
};


int main(){
  foo<int> F;
  return 0;
}

?

[Speedo]

okay, how about this variation? I still get an error on compilation. I tried various combinations of predeclaring each class, but they don't seem to do the trick.

Aside from what they've pointed out about why the typedef won't work, what you're trying to do here is just odd. Using a derived class as the template parameter for its own base class?

[laserlight]

what you're trying to do here is just odd. Using a derived class as the template parameter for its own base class?

It is odd indeed. Read up on the "curiously recurring template pattern".

[jakevdp]

Hello,
I found a solution - I thought I'd share it with you. This was pointed out to me by a friend, and comes from the FLENS source code (see http://flens.sourceforge.net/ ). This compiles, and creates the behavior I hoped for:

template <typename T>
struct TypeInfo;

template<class T>
class policy{
public:
  typedef typename TypeInfo<T>::Type DerivedType;
};

template<class T>
class foo : public policy<foo<T> >{};

template <typename T>
struct TypeInfo<foo<T> >
{
    typedef foo<T> Type;
};

int main(){
  foo<int> F;
  policy<foo<int> >& P = F; // F::DerivedType is foo<int>
  return 0;
}

Essentially, policy:: DerivedType is shorthand for the class that derives from it, as long as that derived type defines a TypeInfo specialization for itself. Kind of a cool trick, and useful, for returning data from a base class which is of the derived class type. This simplifies my code, anyway. Any remarks on this type of structure?

[TheCPUWizard]

Hello,
I found a solution -

Sounds exactly like what Peter_APIT suggested in the very first reply to your question.....a simple forward declaration of...

template <typename T>
struct TypeInfo;

[0xC0000005]

Sounds exactly like what Peter_APIT suggested in the very first reply to your question.....a simple forward declaration of...

While a forward declaration may be necessary, I see that the solution found by jakevdp is substantially different from the code originally posted. The typedef was the problem then and that was addressed by Russco when he said int::fooType is not valid. It now appears to me that the original was just a very bad attempt at implementing the "curiously recurring template pattern" (as pointed out by laserlight) which has now been corrected. Is my analysis wrong?

[Graham]

Hang on, that doesn't do what the original post was trying to achieve. In the OP, you had policy defining a type declared within the template argument

template<class T>
struct policy
{
    typedef typename T::fooType fooType;
};

The one you've just posted is functionally equivalent to

template<class T>
struct policy
{
    typedef T DerivedType;
};

(or has the cold addled my brain, and I'm missing something obvious?)


ETA: I see someone else has had the same thought - maybe it's not just me, then.

[jakevdp]

Right - thanks. The original example was trying for something like this:

template <typename T>
struct TypeInfo;

template<class T>
class policy{
public:
  typedef typename TypeInfo<T>::Type DerivedType;
};

template<class T>
class foo : public policy<foo<T> >{};

template <typename T>
struct TypeInfo<foo<T> >
{
    typedef T Type;
};

int main(){
  foo<int> F;
  policy<foo<int> >& P = F; // P::DerivedType is int
  return 0;
}

Using this, a policy object can know about any of the template parameters of a derived type. That's what I was going for.