Template recursive class

[Jon Slaughter]

I've managed to put together a template class that basicaly creates a
recursive tree that lets you easily specify the "base" class of that tree
and and ending notes and lets you stop the recursive process if you want.

The problem now is to make a Type list so I can specify more than one node
at a time to "attach" a class to. I think I will be able to handle this but
I want to run the code by you guys to see there are any major design flaws.


The code is just a "prototype" and will be rewritten once I get the idea
done. The idea is to get something like

sTree<4, 4, AllClass, MyEndClassLeft, MyEndClassRight, TypeList<Node<2, 3,
MyClassA>, Node<3, 3, MyClassB>, Node<1, 3, MyClassC>> > S;

Which would produce a tree that as for each node a class of AllClass except
the nodes given in the type list and the last nodes are give by
MyEndClassLeft and MyEndClassRight.

Ofcourse right now I can only specify one Node type because I have not
implemented a TypeList.


Anyways, while this models my original problem more than enough I thought it
would be nice to make it as general as I possibly could. But maybe it could
be done much easier? One thing I'm not sure is a good idea is to have the
"user attached" classes be the base classes for the nodes because this might
cause problems with casting? But that was the only way I could see to make
it simple enough without having the user have to worry about deriving things
and all that.

Any ideas?

Thanks, Jon

(The code, again, isn't ment to be perfect... each function in the classes
are just for "looks" and I could have done a better job at something but
please only stick to the real issues)

Oh, one more thing, is there an easy way to have the user choose from using
a vector based container(or whatever type of container) instead of just a
type..

i.e.


sTree<I-1, J, A, L, R, T> Left;

into something like

list<*sTree<I-1, J, A, L, R, T> > Left;

without having to do a crap load of specializing?

i.e.

sTree<4, 4, List, Vector, AllClass, MyEndClassLeft, MyEndClassRight, Node<2,
3, MyClass> > S;

Where sTree uses lists for the Left branches and vectors for the right.



----------------------------------------

#include <iostream>

using namespace std;

struct NullClass { void Null() { } };

template <unsigned int i, unsigned int j, typename T, unsigned int s = 0>
struct Node
{
enum {I = i};
enum {J = j};
enum {S = s};
typedef T Class;
};


template <int I, int J, typename A, typename L, typename R, typename T>
struct sTree : A
{
sTree<I-1, J, A, L, R, T> Left;
sTree<I, J-1, A, L, R, T> Right;
void sTreeFunc() { }
};


// Specializes node type for full recursive process
template <typename A, typename L, typename R, unsigned int I, unsigned int
J, typename T>
struct sTree< I, J, A, L, R, Node<I,J,T,0> > : Node<I,J,T,0>::Class
{
sTree<I, J, A, L, R, T> Left;
sTree<I, J, A, L, R, T> Right;
void Spec() {}
};

// Specializes node type to end left recursive process
template <typename A, typename L, typename R, unsigned int I, unsigned int
J, typename T>
struct sTree< I, J, A, L, R, Node<I,J,T,1> > : Node<I,J,T,1>::Class
{
sTree<I, J, A, L, R, T> Right;
void Spec() {}
};

// Specializes node type to end right recursive process
template <typename A, typename L, typename R, unsigned int I, unsigned int
J, typename T>
struct sTree< I, J, A, L, R, Node<I,J,T,2> > : Node<I,J,T,2>::Class
{
sTree<I, J, A, L, R, T> Left;
void Spec() {}
};

// Specializes node type to end recursive process
template <typename A, typename L, typename R, unsigned int I, unsigned int
J, typename T>
struct sTree< I, J, A, L, R, Node<I,J,T,3> > : Node<I,J,T,3>::Class
{
void Spec() {}
};

// Specializes last "left" node
template <unsigned int J, typename A, typename L, typename R, typename T>
struct sTree<0, J, A, L, R, T> : L
{
void End() { }
};

// Specializes last "right" node
template <unsigned int I, typename A, typename L, typename R, typename T>
struct sTree<I, 0, A, L, R, T> : R
{
void End() { }
};



// User defined classes for "attaching" to the tree
struct AllClass { void All() { } };
struct MyClass { void MyFunc() { } };
struct MyEndClassLeft { void MyEndLeft() { } };
struct MyEndClassRight { void MyEndRight() { } };



int main( int argc, char* argv[] )
{

sTree<4, 4, AllClass, MyEndClassLeft, MyEndClassRight, Node<2, 3, MyClass> >
S;

system("PAUSE");
return 0;
}

 

[benben]

Does it work?

Ben