Функция обмена текущего и следующего за ним элементов стека

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <fstream>
#include <time.h>
#include <locale.h>
 
using namespace std;
 
 
 
 
 
struct Stack { 
    int info;
    Stack* next;
 
} *beg, *t;
 
 
 
void View(Stack*);
void DelAll(Stack**);
Stack* InStack(Stack* p, int in);
void save(Stack** p);
 
int main()
{
    
 
    setlocale(LC_ALL, "RUS");
    cout << "Программа 'Стек' " << endl;
 
    srand(time_t(NULL));
    int i, in, kod, var, add, add1, n = 5;
    while (true) {
        cout << "\n\tСоздать\t - 1.\n\tДобавить\t - 2.\n\tПоказать\t - 3.\n\tУдалить\t -  4.\n\tEXIT\t - 0. :";
        cin >> kod;
        switch (kod)
        {
        case 1:if (kod == 1 && beg != NULL)
        {
            cout << "Пусто!" << endl; break;
        }
               cout << "Введите размер стека ";
               cin >> var;
               n = var;
               
               for (i = 1; i <= n; i++)
               {
                   in = rand() % 100;
                   beg = InStack(beg, in);
               }
               cout << "Стек состоит из " << n << " элементов ";
               break;
        case 2:
            if (kod == 2 && beg != NULL)
                cout << "Введите размер стека ";
            cin >> add1;
            add = add1;
            for (i = 1; i <= add; i++)
            {
                in = rand() % 21;
                beg = InStack(beg, in);
            }
 
            cout << "Добавить " << add << endl;
            break;
 
        case 3: if (!beg) {
            cout << " Стек пуст" << endl; View(beg);
            break;
        }
                cout << "____Стек____ " << endl;
                View(beg); break;
        case 4: DelAll(&beg);
            cout << "Память освобождена" << endl; break;
    
        case 0: if (beg != NULL) DelAll(&beg);
            system("pause");
            return 0;
        }
    }
}
 
 
// Функция добавления элемента в стек
Stack* InStack(Stack* p, int in)
{
    Stack* t = new Stack; //Захватываем память для элемента
    t->info = in; 
    t->next = p; 
    return t;
}
 
// Функция просмотра стека
void View(Stack* p)
{
    Stack* t = p; while (t != NULL)
    {
        cout << " " << t->info << endl; t = t->next;
    }
}
 
// Функция освобождения памяти
void DelAll(Stack** p)
{
    Stack* t;
    while (*p != NULL) {
 
        t = *p;
        *p = (*p)->next;
        delete t;
    }
}

#include <iostream>
 
template<typename T>
class Stack {
public:
    Stack(std::size_t maxSize): maxSize{maxSize}, size{0}, data{new T[maxSize]} {}
    Stack(const Stack<T> &o): maxSize{o.maxSize}, size{o.size}, data{new T[maxSize]} {
        for (std::size_t i = 0; i < size; ++i) {
            data[i] = o.data[i];
        }
    }
    Stack<T> &operator=(const Stack<T> &o) {
        if (&o != this) {
            delete[] data;
            maxSize = o.maxSize;
            size = o.size;
            data = new T[maxSize];
            for (std::size_t i = 0; i < size; ++i) {
                data[i] = o.data[i];
            }
        }
        return *this;
    }
    ~Stack() {
        delete[] data;
    }
 
    // добавление в стек
    void push(const T &value) {
        if (size >= maxSize) {
            throw std::overflow_error("stack overflow");
        }
        data[size++] = value;
    }
 
    // удаление из стека
    void pop() {
        if (size <= 0) {
            throw std::underflow_error("stack underflow");
        }
        --size;
    }
 
    // просмотр верхнего элемента
    const T &top() const {
        if (size <= 0) {
            throw std::underflow_error("stack underflow");
        }
        return data[size-1];
    }
 
    const T &operator[](std::size_t n) const {
        return data[n];
    }
 
    std::size_t getSize() const {
        return size;
    }
 
    std::size_t getMaxSize() const {
        return size;
    }
 
    bool isEmpty() const {
        return size == 0;
    }
 
private:
    std::size_t size;
    std::size_t maxSize;
    T *data;
};
 
template<typename T>
std::ostream& operator<<(std::ostream &out, const Stack<T> &stack) {
    out << "[";
    for (std::size_t i = 0; i < stack.getSize(); ++i) {
        out << stack[i];
        if (i + 1 < stack.getSize()) {
            out << ", ";
        }
    }
    return out << "]";
}
 
int main() {
 
    Stack<int> s{10};
    s.push(1);
    s.push(2);
    s.push(3);
 
    std::cout << s << std::endl;
 
    // обмен местами
    int a = s.top();
    s.pop();
    int b = s.top();
    s.pop();
    s.push(a);
    s.push(b);
 
    std::cout << s << std::endl;
 
    return 0;
}