Question

So I wrote a Linked List based implementation of the Stack ADT recently. However, I’m not quite sure why there is a bit of a discrepancy between how the nodes of the Stack are being declared. The compiler gets very angry and won’t compile until I write them a certain way for certain functions. I’m extremely curious as to why this is the case.

Here are two different methods which the compiler wants two different formats.

Here is my destructor where the compiler wants StackNode *temp.

template <typename DataType>
StackLinked<DataType>::~StackLinked() {
   StackNode *temp;
   while (top != 0) {
       temp = top;
       top = top->next;
       delete temp;
   }
}

Here is my assignment operator overload where the compiler wants StackNode<DataType> *temp.

template <typename DataType>
StackLinked<DataType>& StackLinked<DataType>::operator=(const StackLinked& other) {
    if (this != &other) {
        StackNode<DataType> *newNode, *current, *last;

        if (top != 0) {
           StackNode<DataType> *temp;
           while (top != 0) {
               temp = top;
               top -> top->next;
               delete temp;
           }
        }

        if (other.top == 0) {
            top = 0;
        }
        else {
            current = other.top;
            top = new StackNode<DataType>;
            top->dataItem = current->dataItem;
            top->next = 0;
            last = top;
            current = current->next;

            while (current != 0) {
                newNode = new StackNode<DataType>;
                newNode->dataItem = current->dataItem;
                newNode->next = 0;
                last-> next = newNode;
                last = newNode;
                current = current->next;
            }
        }
    }
    return *this;
}

I don’t know why this is, but the unknown is bothering me.

Note: My StackNode class is an inner class of the StackLinked class.

EDIT: Class declaration:

#ifndef STACKARRAY_H
#define STACKARRAY_H

#include <stdexcept>
#include <iostream>

using namespace std;

#include "Stack.h"

template <typename DataType>
class StackLinked : public Stack<DataType> {

public:

StackLinked(int maxNumber = Stack<DataType>::MAX_STACK_SIZE);
StackLinked(const StackLinked& other);
StackLinked& operator=(const StackLinked& other);
~StackLinked();

void push(const DataType& newDataItem) throw (logic_error);
DataType pop() throw (logic_error);

void clear();

bool isEmpty() const;
bool isFull() const;

void showStructure() const;

private:
class StackNode {
  public:
StackNode(const DataType& nodeData, StackNode* nextPtr);
DataType dataItem;
StackNode* next;
};

StackNode* top;
};

#endif  

If any other details are needed. Just ask! Thank you for your time!

Answer 1

From the code you showed, StackNode<DataType> is not correct, because StackNode is not a class template.

This makes me think you have a template also named StackNode that the compiler is finding. Go check whether any of your files contain another version of StackNode.