Stack Palindrome

///////////////////////////////////////////////////
///stack.h
//////////////////////////////////////////////////
template <class T>
class Stack{
private:
    int size;
    int top;
    T *stackPtr;

public:
    Stack(int n);
    Stack(Stack &);
    Stack();
    ~Stack();
    int getTop();
    int getSize();
    bool push(const T &);
    bool pop(T &);
    bool pop();
    bool isEmpty() const;
    bool isFull() const;
    void print() ;

    friend bool operator ==(const Stack<T>& stack1, const Stack<T>& stack2);
};//end Stack class


template<class T>
Stack <T >::Stack(int n):size(n),top(-1)
{
    stackPtr = new T[n];
}//end default constructor
template<class T>
Stack <T >::Stack():size(maxStack),top(-1)
{
    stackPtr = new T[maxStack];
}//end default constructor

template<class T>
Stack <T>::~Stack()
{
    delete [] stackPtr;
}//end destructor

template<class T>
bool  Stack <T >::push(const T &dato){
    if(!(this->isFull()))
    {
        this->top++;
        *(stackPtr +top) = dato;
        return true;
    }//end if
    else
        return false;
}//end function push

template<class T>
bool  Stack <T >::pop(T &dato){
    if(!(this->isEmpty()))
    {
        dato = *(stackPtr +top);
        this->top--;
        return true;
    }//end if
    else
        return false;
}//end function pop

template<class T>
bool  Stack <T >::pop()
{
    if(!(this->isEmpty()))
    {
        this->top--;
        return true;
    }//end if
    else
        return false;
}//end function pop

template<class T>
bool  Stack <T >::isEmpty() const
{
    if(this->top == -1)
        return true;
    else
        return false;
}//end function isEmpty

template<class T>
bool  Stack <T >::isFull() const
{
    if(this->top == (this->size -1))
        return true;
    else
        return false;
}//end function isFull

template<class T>
int Stack <T >:: getTop()
{
    return(this->top);
}//end function getTop

template<class T>
int Stack <T >:: getSize()
{
    return(this->size);
}//end function getSize

template<class T>
Stack <T >::Stack(Stack &tempStack)
{
    T dato;
    if(tempStack.getTop() == -1){
        stackPtr = NULL;
        top = -1;
    } //end if
    else{
        stackPtr = new T[tempStack.size];
        size = tempStack.getSize();
        top = -1;
        Stack tempStack1(size);        //Usa un stack temporero ,       elementos en orden contario
        while(!tempStack.isEmpty())
        {
            tempStack.pop(dato);
            tempStack1.push(dato);
        }//end while
        tempStack.top = tempStack1.getTop();

        while(!tempStack1.isEmpty())        //Los retorna en el orden original
        {
            tempStack1.pop(dato);
            push(dato);
        }//end while
    }//end else
}//end copy constructor

template<class T>
void Stack <T >::print()
{
    T dato;
    int tempTop;
    tempTop = this->getTop();
    cout<<"Stack:";
    while(!(this->isEmpty())){
        this->pop(dato);
        cout<<dato<<",";
    } //end while
    this->top = tempTop;
    cout<<endl;
}//end function print

template<class T>
bool operator==(const Stack<T>& stack1, const Stack<T>& stack2) {

 /*return (stack1.size == stack2.size &&
            stack1.top == stack2.top &&
           stack1.stackPtr == stack2.stackPtr
           );*/
}


//////////////////////////////////////////////////
///main.cpp
/////////////////////////////////////////////////
#include<iostream>
using namespace:: std;
#include "stack.h"
int main(){
    int n;
    char dato;
    bool palindrome;

    cout<<"Entre la cantidad de caracteres al Stack:";
    cin>>n;
    Stack<char> stackChar(n);
    for(int i=0;i<n;i++)

    {
        cout<<"Entre el valor:";
        cin>>dato;
        stackChar.push(dato);
    }//end for
    Stack<char> stack(stackChar);
    cout<<"Stack Original:";
    stack.print();
    cout<<"Stack copy constructor:";
    stackChar.print();

    palindrome = (stackChar == stack);
    cout << palindrome;

    stackChar.pop(dato);
    cout<<"El valor "<<dato<<" fue eliminado del Stack\n";
    cout<<"El tope del stack esta apuntando al indice    ";
    stackChar.print();
    if(!stackChar.pop())

        cout<<"El stack esta vacio\n";

    else

        stackChar.print();

    if(!stackChar.pop())

        cout<<"El stack esta vacio\n";

    else

        stackChar.print();
    if(!stackChar.pop())
        cout<<"El stack esta vacio\n";
    else
        stackChar.print();





    system("pause");
    return 0;

}