I got many errors on doing palindrome checking using stack n queue methods

#include <iostream>
#include <string>
#include <stack>
#include <queue>

using namespace std;

class Stack
{
    Node*top;
    int count;

public:
    Stack();
    void push(char);
    char topGet();
    char pop();
    void display();
    bool isEmpty();
    int size();
};

class Queue
{
    Node *tail;
    Node *head;
    int count;
    char data;

public:
    Queue();
    void Dequeue();
    void Enqueue(char);
    bool isEmpty();
    bool isFull();
    void display();
    int size();
    char topGet();
};

class Node
{
    Node *next;
    char data;

public:
    Node();
    void setNext(Node *);
    void setData(char);
    Node* getNext();
    char getData();
};

bool isPallindrome(string);
int main()
{
    string input;
    bool flag = true;
    while (flag) {
        cout << "Enter word to see PALINDROME OR NOT, Press x for Quit" << endl;
        cout << "> ";
        getline(cin, input);
        if (input == "x" || input=="X")
        {
            flag = false;
            return 0;

        }

        if (isPallindrome(input))
        {
            cout << input << " is aPallindrome" << endl;
        }
        else
        {

            cout << input << " is not aPallindrome" << endl;
        }


    }
}

bool isPallindrome(string str)
{
    Stack *s;
    Queue *q;

    while (true) {
        s = new Stack();
        q = new Queue();
        for (int i = 0; i < str.length(); i++) {
            s->push(str[i]);
            q->Enqueue(str[i]);
        }
        bool eq = true;
        if (s->size() == q->size()) {
            while (!s->isEmpty()) {
                if (s->topGet() == q->topGet())
                {
                    eq = true;
                }
                else
                {
                    eq=false;
                }
                s->pop();
                q->Dequeue();

            }
        }
        else {
            eq = false;
        }
        return eq;
    }
}

Stack::Stack()
{
    top = NULL;
    count = 0;
}
void Stack::push(char s)
{
    Node*newNode = new Node();
    newNode->setData(s);
    newNode->setNext(top);
    top = newNode;
    count++;
}

bool Stack::isEmpty()
{
    if (count == 0)
        return true;
    return false;
}
char Stack::topGet()
{
    if (count == 0)
        throw "Stack is Empty ";
    char tempS;
    tempS = top->getData();
    return tempS;
}
char Stack::pop()
{

    if (isEmpty())
        return NULL;
    Node *temp;
    char tempS;
    tempS = top->getData();

    temp = top;
    top = top->getNext();
    delete temp;
    count--;
    return tempS;
}
void Stack::display()
{
    cout << topGet() << " ";
}
int Stack::size()
{
    return count;
}

Queue::Queue()
{
    head = new Node();
    tail = new Node;
    data = ' ';
    count = 0;
}

void Queue::Dequeue()
{
    Node *temp;
    if (isEmpty())
    {
        throw "There is Nothing in front to Queue ";
    }
    temp = head;
    data = temp->getData();
    head = head->getNext();
    temp = NULL;
    delete temp;
    count--;

}

void Queue::Enqueue(char val)
{
    Node *newNode = new Node();
    data = val;
    newNode->setData(val);
    newNode->setNext(NULL);
    if (head->getNext() == NULL)
    {
        head->setNext(newNode);
        head->setData(val);
        tail->setNext(newNode);
        tail = head;
    }
    else
    {
        tail->setData(val);
        tail->setNext(newNode);
        tail = newNode;
    }
    count++;
}

bool Queue::isEmpty()
{
    if (count == 0)
    {
        return true;
    }
    return false;

}
void Queue::display()
{
    cout << data << " ";
}
bool Queue::isFull()
{
    if (count == 10)
    {
        return true;
    }
    return false;
}
int Queue::size()
{
    return this->count;
}
char Queue::topGet()
{
    if (count == 0)
        throw "Stack is Empty ";
    return head->getData();
}

Node::Node()
{
    next = NULL;
    data = NULL;

}
void Node::setNext(Node*next)
{
    this->next = next;
}
void Node::setData(char data)
{
    this->data = data;
}
Node*Node::getNext()
{
    return this->next;
}
char Node::getData()
{
    return  this->data;
}