Из элементов первой очереди, которых нет во второй, сформировать стек

#include <iostream>
#include <time.h>
#include <utility>
#include <initializer_list>
 
using namespace std;
 
// начало функций для массива
struct Stack {
    int top;
    int* data;
};
 
void InitStack(Stack& st, int capacity) {
    st.data = new int[capacity];
    st.top = -1;
}
 
void push(Stack& st, int value) {
    st.data[++st.top] = value;
}
 
int pop(Stack& st) {
    return st.data[st.top--];
}
 
void nullStack(Stack& st) {
    st.top = -1;
}
 
bool empty(Stack& st) {
    return st.top == -1;
}
 
void print(Stack& st) {
    if (empty(st)) cout << "Stack is empty" << endl;
    else {
        int tmp = st.top;
        while (!empty(st)) cout << pop(st) << " ";
        st.top = tmp;
    }
    cout << endl;
}
 
struct Queue1 {
    int head, tail, size;
    int* data;
};
 
void nullQueue(Queue1& q) {
    q.head = 0;
    q.tail = q.size - 1;
}
 
void InitQueue(Queue1& q, int capacity) {
    q.size = capacity + 1;
    q.data = new int[q.size];
    nullQueue(q);
}
 
int next(Queue1& q, int n) {
    return(n + 1) % q.size;
}
 
bool empty(Queue1& q) {
    return next(q, q.tail) == q.head;
}
 
void add(Queue1& q, int value) {
    if (next(q, next(q, q.tail)) == q.head)
        cout << "Queue overflow" << endl;
    else {
        q.tail = next(q, q.tail);
        q.data[q.tail] = value;
    }
}
 
int del(Queue1& q) {
    if (empty(q)) {
        cout << "Queue is empty" << endl;
        return 0;
    }
    else
    {
        int d = q.data[q.head];
        q.head = next(q, q.head);
        return d;
    }
}
 
void print(Queue1& q) {
    if (empty(q)) cout << "Queue is empty";
    else {
        int tmph = q.head;
        int tmpt = q.tail;
        while (!(empty(q))) cout << del(q) << " ";
        q.head = tmph;
        q.tail = tmpt;
    }
    cout << endl;
}
// конец функций для массива
 
// начало функций для линейного списка
struct Node {
    int data;
    Node* next;
};
 
void InitStack(Node*& top) {
    top = NULL;
}
 
void push(Node*& top, int value) {
    Node* tmp = new Node;
    tmp->next = top;
    top = tmp;
    top->data = value;
}
 
int pop(Node*& top) {
    Node* tmp = top;
    int d = top->data;
    top = top->next;
    delete(tmp);
    return d;
}
 
bool empty(Node*& top) {
    return top == NULL;
}
 
void nullStack(Node*& top) {
    Node* tmp;
    while (!empty(top)) {
        tmp = top;
        top = top->next;
        delete(tmp);
    }
}
 
void print(Node*& top) {
    Node* tmp = top;
    while (!empty(tmp)) {
        cout << tmp->data << " ";
        tmp = tmp->next;
    }
    cout << endl;
}
 
 
class Queue {
public:
    //int size;
    Node* next;
    Node* head, * tail;
    int* data;
    Queue() {
        //this->size = size;
        //this->data = new int[size];
        data = NULL;
        head = NULL;
        tail = NULL;
    }
 
    bool empty() {
        return head == NULL;
    }
 
    void add(int value) {
        if (empty()) {
            head = new Node;
            head->data = value;
            head->next = NULL;
            tail = head;
        }
        else {
            tail->next = new Node;
            tail = tail->next;
            tail->data = value;
            tail->next = NULL;
        }
    }
 
    int del() {
        if (empty()) {
            cout << "Queue is empty" << endl;
            return 0;
        }
        else {
            int d = head->data;
            Node* tmp = head;
            head = head->next;
            delete(tmp);
            return d;
        }
    }
 
    void nullQueue() {
        Node* tmp;
        while (!empty()) {
            tmp = head;
            head = head->next;
            delete(tmp);
        }
    }
 
    void print() {
        Node* tmp = head;
        while (tmp != tail) {
            cout << tmp->data << " ";
            tmp = tmp->next;
        }
        cout << tail->data << endl;
    }
 
    Queue(Queue&& a) {
        std::swap(data, a.data);
        //std::swap(size, a.size);
        std::swap(head, a.head);
        std::swap(tail, a.tail);
    }
 
        /*int i = 0;
        this->data = new int[a.size];
        this->size = a.size;
        while (a.head != a.tail) {
            Node* tmp = a.head;
            this->head = tmp;
            tmp = tmp->next;
        }
        for (i; i < size; i++) {
            this->data[i] = a.data[i];
        }
        this->tail = a.tail;
        this->data[i] = a.data[i];
    }*/
 
};  // конец функций для линейного списка
 
void main() {
    srand(time_t(0));
    //int n = rand() % 10 + 1, S;
    int n, S = 0;
    cout << "Count: ";
    cin >> n;
    bool b;
    cout << "Press 1 for array or 2 for linear list" << endl;
    cin >> S;
    switch (S) {
    case 1:
    {
        Stack s;
        Queue1 q1, q2;
        InitQueue(q1, n);
        for (int i = 0; i < n; i++) {
            add(q1, rand() % 1001);
        }
        cout << "Queue1: ";
        print(q1);
        InitQueue(q2, n);
        for (int i = 0; i < n; i++) {
            add(q2, rand() % 1001);
        }
        cout << "Queue2: ";
        print(q2);
        InitStack(s, n);
        for (int i = 0; i <= q1.size; i++) {
            b = false;
            for (int j = 0; j <= q2.size; j++) {
                if (q1.data[i] != q2.data[j])
                    b = true;
                else {
                    b = false;
                    break;
                }
            }
            if (b == true)
                push(s, q1.data[i]);
        }
        cout << "New stack: ";
        if (!empty(s))
            print(s);
        else
            cout << "stack is empty" << endl;
        break;
    }
    case 2:
    {
        Node* s;
        Queue Q1, Q2;
 
        for (int i = 0; i < n; i++) {
            Q1.add(rand() % 10);
        }
        cout << "Queue1: ";
        Q1.print();
        for (int i = 0; i < n; i++) {
            Q2.add(rand() % 10);
        }
        cout << "Queue2: ";
        Q2.print();
 
        InitStack(s);
        while (!Q1.empty()) {
            int d1 = Q1.del();
            b = true;
            Queue Q3(std::move(Q2));
            while (!Q3.empty()) {
                int d2 = Q3.del();
                if (d1 == d2)
                    b = false;
            }
            if (b == true)
                push(s, d1);
            Q3.nullQueue();
        }
        cout << "New stack: ";
        if (!empty(s))
            print(s);
        else
            cout << "stack is empty" << endl;
        break;
    }
    default:
        cout << "This program doesn't have another function" << endl;
        break;
    }
    std::system("pause");
}