TITLE: Recursive templates

PROBLEM: Joshua Lam <lam@spectra.com>

[Part 1]

template <class X, class Y>
class MyClass {
  public:
    MyClass(){}
    MyClass<Y, X> *another;  // note the X and Y are flipped
                             // can I do this???
};

[Part 2]

MyClass<int, float>* a = new MyClass<int, float>;
MyClass<float, int>* b = new MyClass<float, int>;
a->another = b;   // compiler complains here!!!


RESPONSE: jamshid@emx.cc.utexas.edu (Jamshid Afshar), 6 Sep 93

[Part 1]

Yes, that's legal.  Some compilers have problems, though, with the use
of "recursive" templates like this.  Recursive template examples which
I believe are or should/will be legal include:

1)	template<int DIMS> class Array {
	   //...
	public:
	   Array<DIMS-1> operator[](int index);
	   // operator[] return type should only expand when func. called
	};

2)	template<class Letter> class Envelope : public Letter {/*...*/};
	class String {
	public:
	   Envelope<String> operator+(const char*);
	};

3)	template<class Container> class Iter {
	   Container* container;
	   Container::IterState state;
	};
	template<class T> class List {
	public:
	   typedef Iter<List<T> > MyIter;
	   typedef int IterState;
	   // typedefs should be parsed on an "as-needed" basis
	};
	List<int>::MyIter i;

4)	template<class T1, class T2> struct Promote : Promote<T2,T1> {};
	struct Promote<complex,double> { typedef complex Result; };
	complex c; double d;
	Promote<complex,double> r = c+d;

The premise is that templates classes, temlate member/friend function
return and parameter types, and typedefs and classes nested in
template classes should be expanded on an "as-needed", incremental
basis to allow for recursive templates and specializations.

[Part 2]

You probably are using Cfront 3.0.1 which had a lot of problems.  BC++
3.1, gcc 2.4.5 and Cfront 3.0.2 accept your code.