Re: Problems with c++ templates

From:

"pratik" <pratikjpatel@gmail.com>

Newsgroups:

comp.lang.c++.moderated

Date:

24 Oct 2006 18:08:42 -0400

Message-ID:

<1161705094.151262.275260@k70g2000cwa.googlegroups.com>

I guess you wanted to do this...

#include <iostream>

using std::cout;
using std::endl;

template < typename T >
class Stack
{
    private:
        struct node
        {
            T data;
            node * next;
            explicit node ( const T & data) : data (data),
next(0) {}
        };

        node * head;
        unsigned int size;

    public:
        explicit Stack(unsigned int size) : head(0), size(size) {}

        void push(T & val);
        T pop();
        inline bool isFull() const;
        inline bool isEmpty() const;
        inline int getSize() const;
        void printStack() const;
};

template < typename T >
void Stack<T>::push(T & val)
{
    if (isFull())
    {
        cout << " Stack overflow error " << endl;
        return;
    }

    node * temp = new node(val);

    if (!head)
    {
        head = temp;
    }
    else
    {
        temp->next = head ;
        head = temp;
    }

    size = size - 1;
    return;
}

template < typename T >
T Stack<T>::pop()
{
    if (isEmpty())
    {
        cout << " Stack underflow error " << endl;
        return T();
    }
    else
    {
        node * temp = head;
        head = head->next;
        T data = temp->data;
        delete temp;
        return data;
    }
}

template < typename T >
bool Stack<T>::isFull() const
{
    return !(size);
}

template < typename T >
bool Stack<T>::isEmpty() const
{
    return size;
}

template < typename T >
int Stack<T>::getSize() const
{
    return size;
}

template < typename T >
void Stack<T>::printStack() const
{
    if (!head)
    {
        cout << " Stack is empty " << endl;
    }
    else
    {
        node * temp = head;

        cout << endl << " Starting at the top. Size = " << getSize()
<< endl;

        int i = 1;

        while (temp)
        {
            cout << " Element " << i << " --> " << temp->data <<
endl;
            temp = temp->next;
            i++;
        }
    }
    return;
}

int main()
{
    Stack<int> s(10);

    for (int i = 100; i < 1199; i += 100)
    {
        s.push(i);
        s.printStack();
    }

    return 0;
}
Mr B wrote:

Hi all,

I'm currently studying templates in C++ and i'm really puzzled by why
the compiler doesn't like my code!!! I think I understand the concept.
I have created a Stack class which has a pointer to a Node class. The
Node class stores a value and a pointer to the previously added node.
My code is below:

//--------------------------------------------------------------------------
----

template <typename T>
class Node
{
   friend class MyStack;

   private:
         Node *PreviousNode;
         T NodeVal;

   public:
         Node(T InitVal);
         T GetVal() { return NodeVal; }
};

//--------------------------------------------------------------------------
----

template <typename T>
Node<T>::Node(T InitVal)
{
NodeVal = InitVal;
PreviousNode=NULL;
}

//--------------------------------------------------------------------------
----

template <typename DT>
class MyStack
{
   private:
         Node<DT> *TopNode;
         int MaximumNodes;
         int NumNodes;

   public:
         MyStack(int Size);
         ~MyStack();
         void Push(DT Val);
         DT Pop();
};

//--------------------------------------------------------------------------
----

MyStack::MyStack(int Size)
{
   MaximumNodes = Size;
   NumNodes=0;
   TopNode = NULL;
}

//--------------------------------------------------------------------------
----

MyStack::~MyStack()
{
   while(NumNodes > 0)
   {
     Pop();
   }
}

//--------------------------------------------------------------------------
----

template <typename DT>
void MyStack<DT>::Push(DT Val)
{
   Node *NewNode;

   if (NumNodes < MaximumNodes)
   {
     NewNode = new Node(Val);

     NewNode->PreviousNode = TopNode;
     TopNode = NewNode;

     NumNodes++;
   }
   else { throw "Stack Overflow error"; }
}

//--------------------------------------------------------------------------
----

template <typename DT>
DT MyStack<DT>::Pop()
{
   Node *Popped;
   DT PopVal;

   if(NumNodes >= 1)
   {
     Popped = TopNode;
     TopNode = TopNode->PreviousNode;
     PopVal=Popped->GetVal();

     delete Popped;
     NumNodes--;

     return PopVal;
   }
   else { throw "Stack Underflow error"; }
}

//--------------------------------------------------------------------------
----

void main()
{
   try
   {
     MyStack <int>*NewStack = new MyStack<int>(5);
     NewStack->Push(6);
     NewStack->Push(30);
     NewStack->Push(2);
     NewStack->Push(4);
     NewStack->Push(7);
     cout << NewStack->Pop() << "\n";
     cout << NewStack->Pop() << "\n";
     cout << NewStack->Pop() << "\n";
     cout << NewStack->Pop() << "\n";
     cout << NewStack->Pop() << "\n";
   }

   catch (char *Str)
   {
     puts(Str);
   }

   delete NewStack;

   getchar();
}

Amongst errors I get a 'Type mismatch in redeclaration of 'MyStack''
Could somebody please tell me where i'm going wrong!!

Thanks

Daniel

--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]