Stack и указатели c++

#ifndef _LINKED_STACK
#define _LINKED_STACK
#include "StackInterface.h"
#include "Node.h"
template < class ItemType > class LinkedStack :public StackInterface < ItemType >
{
private:
    Node < ItemType > *topPtr;  // Pointer to first node in the chain;
    // this node contains the stacks top
    
public:
    // Constructors and destructor:
    LinkedStack();  // Default constructor
    LinkedStack(const LinkedStack < ItemType > &aStack);    // Copy constructor
 
    virtual ~LinkedStack(); // Destructor
    // Stack operations:
    bool isEmpty() const;
 
    bool push(const ItemType &newItem);
 
    bool pop();
 
    ItemType peek() const;
 
    //ItemType peek2(int nom) ;
};  // end LinkedStack

template < class ItemType > LinkedStack < ItemType >::LinkedStack() :topPtr(nullptr)
{
    top = 0;
    StackPtr = new ItemType[3];
}   // end default constructor
 
template < class ItemType > LinkedStack < ItemType >::LinkedStack(const LinkedStack < ItemType > &aStack)
{
    // Point to nodes in original chain
    Node < ItemType > *origChainPtr = aStack->topPtr;
    if (origChainPtr == nullptr)
    {
 
        topPtr = nullptr;   // Original bag is empty
    }
    else
    {
        // Copy first node
        topPtr = new Node < ItemType >();
        topPtr->setItem(origChainPtr->getItem());
        // Point to first node in new chain
        Node < ItemType > *newChainPtr = topPtr;
        // Copy remaining nodes
        while (origChainPtr != nullptr)
        {
            // Advance original-chain pointer
            origChainPtr = origChainPtr->getNext();
            // Get next item from original chain
            ItemType nextItem = origChainPtr->getItem();
 
            // Create a new node containing the next item
            Node < ItemType > *newNodePtr = new Node < ItemType >(nextItem);
            // Link new node to end of new chain
            newChainPtr->setNext(newNodePtr);
            // Advance pointer to new last node
            newChainPtr = newChainPtr->getNext();
            top++;
            int count = 0;
            count++;
        }   // end while
        newChainPtr->setNext(nullptr);  // Flag end of chain
    }   // end if
    StackPtr = new ItemType[count];
}  // end copy constructor
 
template < class ItemType > LinkedStack < ItemType >::~LinkedStack()
{
    // Pop until stack is empty
    while (!isEmpty())
        pop();
}   // end destructor
 
template < class ItemType > bool LinkedStack < ItemType >::isEmpty() const
{
    return topPtr == nullptr;
}   // end isEmpty
 
template < class ItemType > bool LinkedStack < ItemType >::push(const ItemType & newItem)
{
    try
    {
        Node < ItemType > *newNodePtr = new Node < ItemType >(newItem, topPtr);
        topPtr = newNodePtr;
        newNodePtr = nullptr;
        return 0;
    }
    catch(...)
    {
        return 1;
    }
 
}// end push
    template < class ItemType > bool LinkedStack < ItemType >::pop()
    {
        bool result = false;
 
        if (!isEmpty())
        {
            // Stack is not empty; delete top
            Node < ItemType > *nodeToDeletePtr = topPtr;
            topPtr = topPtr->getNext();
            // Return deleted node to system
            nodeToDeletePtr->setNext(nullptr);
            delete nodeToDeletePtr;
 
            nodeToDeletePtr = nullptr;
            result = true;
        }   // end if
        return result;
    } // end pop
    template < class ItemType > ItemType LinkedStack < ItemType >::peek() const
    {
        // Stack is not empty; return top
        return topPtr->getItem();
    } // end getTop

#include "Node.h"
#include <cstddef>
#include <iomanip>
template < class ItemType > Node < ItemType >::Node() :next(nullptr)
{
}   // end default constructor
 
template < class ItemType > Node < ItemType >::Node(const ItemType & anItem) :
item(anItem),
next(nullptr)
{
}   // end constructor
 
template < class ItemType > Node < ItemType >::Node(const ItemType & anItem, Node < ItemType > *nextNodePtr) :
    item(anItem),
    next(nextNodePtr)
{
}   // end constructor
 
template < class ItemType > void Node < ItemType >::setItem(const ItemType & anItem)
{
    item = anItem;
}   // end setItem
 
template < class ItemType > void Node < ItemType >::setNext(Node < ItemType > *nextNodePtr)
{
    next = nextNodePtr;
}   // end setNext
 
template < class ItemType > ItemType Node < ItemType >::getItem() const
{
    return item;
}   // end getItem
 
template < class ItemType > Node < ItemType > *Node < ItemType >::getNext() const
{
    return next;
}   // end getNext

Node<ItemType> check* = topPtr->getNext();
        ItemType second = check->getitem();
 
        return second;