Is it possible to use a template-like approach for classes?

[Avon]

Hello there. Long time no post. :P Well here goes...

I'm writing a program that supports many data structures (stacks,heaps etc.) made from scratch. However the program does not limit you to just one stack, one heap etc. but you can have as many as you like. I'm looking for a way to store all the different stacks into one singly-linked list and then all the heaps into another singly-linked list etc. So basically I'd like to make a class (for example "class linkedlist") that supports a list that is not dependant on each data structure. It's confusing but maybe you'll get what I mean by code:

class linkedlist
{
private:
    struct structureIDs
    {
        int ID;
        <<class name goes here>> newStructure;
        struct structureIDs *next;
    }*head;
public:
//...
};

That's the general idea... Where <<class name goes here>> is the name of the class associated to the data structure. So for a list that "keeps" all the stacks you'd have:

class linkedlist
{
private:
    struct structureIDs
    {
        int ID;
        stack stackno1; //Assuming that the class that creates a stack is named "stack"
        struct structureIDs *next;
    }*head;
public:
//...
};

Whereas for a heap you'd have...

class linkedlist
{
private:
    struct structureIDs
    {
        int ID;
        heap heapno1; //Assuming that the class that creates a heap is named "heap"
        struct structureIDs *next;
    }*head;
public:
//...
};

Now the problem is that by this method you'd have to completely write new classes for stack-linkedlists, for heap-linkedlists etc. Is there any way to "tell" the compiler to expect a class at that point but not determine its kind? (Something like templates?)...

Really hope you people answer, thanks in advance!

[kittu513]

Why not use templates itself

[weaknessforcats]

You might consider a template for the nodes. Maybe:

template <class T>
class Node
{
private:
    T theData;
};
template <class T>
class LinkedList
{
    private:
    Node<T>* start;
    Node<T>* end;
    Node<T>* current;
};
 

Then you can create a linked list of any type:

LinkedList<int> IntList;
LinkedList<MyClass> MyClassList;
//etc...