My teacher issued an assignment for us to implement a stack and node class based off of his header files, and then to code a postfix expression calculator using the stack and node classes that we implement. When I tried to generate an instance of my stack class, VS threw me a linker error, citing "scalar deleting destructor". I tried commenting out the contents of one/both of my destructors, but the error persists. Can anyone give me a hand?

Node.h

template < class T>

	class node
	{
 	 public: 
	    T info;			//member to store the data of the node

	    node<T>* next;	//member to hold pointer to next node

	    node();			//default constructor

	    node(T);		//constructor with 1 parameter for data

	    ~node();		//destructor
 	 };

Node.cpp

#include "Node.h"

//default constructor
template <class T>
node<T>::node () :
info (new T),
next (NULL)
{}

//constructor with 1 parameter for data
template <class T>
node<T>::node (T data)
{
	info = new T data;
	next = NULL;
}

// destructor
template <class T>
node<T>::~node()
{ delete info; }

Stack.h

#include "Node.h"

template < class T>

	class Stack{

	private:   	       
	    node<T>  * top;	//pointer to the top node on the stack

		int count;		// keep track the number of items on stack

	public:
		Stack(void);  //the "constructor"

		~Stack(); //class destructor - free up used memory

	    void push(T a);  // add (push)  the given item a onto the stack

	    T pop(void);    // returns and removes the top item on the stack
	       
	    T peek(void);    // returns the top item without removing it from stack

		bool isEmpty() const; //return true if the stack has no elements

		int get_count(); // returns the count of  nodes in the stack
	 };

Stack.cpp

#include "Stack.h"

//default constructor
template <class T>
Stack<T>::Stack()
{
	top = 0;
	count = 0;
}




//accessor for the count member
template <class T>
int Stack<T>::get_count ()
{ return count; }




//method to determine if the list is empty
template <class T>
bool Stack<T>::isEmpty () const
{
	if (count == 0)
		return true;
	else
		return false;
}




// destructor
template <class T>
Stack<T>::~Stack()
{
	while (!isEmpty())
		pop();
}




//method to pop off the top item of the list,
//returning its value and removing it from the list
template <class T>
T Stack<T>::pop ()
{
	if (isEmpty())
		throw Underflow();				//if the stack is empty, throw underflow

	node<T> *topHolder = top;			//hold the top node in a pointer
	top = top->next;					//set the top to the next node in the stack
	T storedValue = topHolder->info;	//store the value of the old top node
	
	delete topHolder;					//delete the old top node
	--count;							//decrement the number of nodes in the stack

	return storedValue;					//return the value of the node that was popped
}




//method to return the data of the top node without
//removing it from the list
template <class T>
T Stack<T>::peek ()
{
	if (isEmpty())
		throw Underflow();				//if the stack is empty, throw underflow

	return top->info;					//return the info stored in the top node
}




//method to push a new node onto the top of the list
template <class T>
void Stack<T>::push (T a)
{
	node newTop = new node(a);			//allocate and construct the new node for the top of the stack
	if (!isEmpty())
		newTop.next = top->next;		//set the next member of the new node to the current top node on the stack

	top = *newTop;						//set the top member of the stack to a pointer to the newTop

	++count;							//increment the number of nodes in the stack
}

Any help at all would be appreciated!
~SunnyD

This article has been dead for over six months. Start a new discussion instead.