Реализовать с использованием шаблона класса стек

Помогите пожалуйста реализовать данную задачу с помощью шаблона стека.

Сама задача на скрине Программа без шаблона

main.cpp

#include <iostream>
#include <clocale>
#include <Stack.h>

using namespace std;

struct Node
{
    int number;
    int info;
    Node* p;
};
void add_car(Node** top, int number);
void delete_car(Node** top, int number);
int main()
{
    setlocale(LC_ALL, "Russian");
    int number;
    Node* top1 = 0;
    int menu = 0;
    do
    {
        cout << "1.Добавить машину" << endl;
        cout << "2.Удалить машину" << endl;
        //cout << "4.Показать гараж" << endl;
        cout << "3.Выход" << endl;
        cin >> menu;
        switch (menu)
        {
        case 1:
            cout << "Введите номер машины" << endl;
            cin >> number;
            add_car(&top1, number);
            system("pause");
            system("cls");
            break;
        case 2:
            cout << "Введите номер машины" << endl;
            cin >> number;
            delete_car(&top1, number);
            system("pause");
            system("cls");
            break;
        }
    } while (menu != 3);
    return 0;
}
void add_car(Node** top, int number)
{
    Node* pv = new Node;
    pv->p = 0;
    pv->number = number;
    cout << "Машина с номером " << ' ' << pv->number << ' ' << "въехала на стоянку" << endl;
    pv->info = 0;
    if (*top == 0)
    {
        *top = pv;
    }
    else
    {
        pv->p = *top;
        *top = pv;
    }
}
void delete_car(Node** top, int number)
{
    Node* tmp = *top;
    Node* tmp2 = *top;
    Node* pr = 0;
    while ((tmp != 0) && (tmp->number != number))
    {
        pr = tmp;
        tmp = tmp->p;
    }
    if (tmp == 0)
    {
        cout << "Машины с данным номером нет на стоянке" << endl;
    }
    else
    {
        cout << "Машина с номером" << ' ' << tmp->number << ' ' << "выезжала со стоянки для беспечения выезда других автомобилей" << ' ' << tmp->info++ << ' ' << "раз" << endl;
        while (tmp2 != tmp)
        {
            tmp2->info++;
            tmp2 = tmp2->p;
        }
        if (pr != 0)
            pr->p = tmp->p;
        if (tmp == *top)
            *top = (*top)->p;
        delete tmp;
    }
}

Сделать например с помощью такого шаблона

Stack.h

#ifndef STACK_H
#define STACK_H


#include <cassert> // для assert
#include <iostream>

#include <iomanip> // для setw

template <typename T>
class Stack
{
private:
    T* stackPtr;                      // указатель на стек
    const int size;                   // максимальное количество элементов в стеке
    int top;                          // номер текущего элемента стека
public:
    Stack(int = 10);                  // по умолчанию размер стека равен 10 элементам
    Stack(const Stack<T>&);          // конструктор копирования
    ~Stack();                         // деструктор

    inline void push(const T&);     // поместить элемент в вершину стека
    inline T pop();                   // удалить элемент из вершины стека и вернуть его
    inline void printStack();         // вывод стека на экран
    inline const T& Peek(int) const; // n-й элемент от вершины стека
    inline int getStackSize() const;  // получить размер стека
    inline T* getPtr() const;         // получить указатель на стек
    inline int getTop() const;        // получить номер текущего элемента в стеке
};

// реализация методов шаблона класса STack

// конструктор Стека
template <typename T>
Stack<T>::Stack(int maxSize) :
    size(maxSize) // инициализация константы
{
    stackPtr = new T[size]; // выделить память под стек
    top = 0; // инициализируем текущий элемент нулем;
}

// конструктор копирования
template <typename T>
Stack<T>::Stack(const Stack<T>& otherStack) :
    size(otherStack.getStackSize()) // инициализация константы
{
    stackPtr = new T[size]; // выделить память под новый стек
    top = otherStack.getTop();

    for (int ix = 0; ix < top; ix++)
        stackPtr[ix] = otherStack.getPtr()[ix];
}

// функция деструктора Стека
template <typename T>
Stack<T>::~Stack()
{
    delete[] stackPtr; // удаляем стек
}

// функция добавления элемента в стек
template <typename T>
inline void Stack<T>::push(const T& value)
{
    // проверяем размер стека
    assert(top < size); // номер текущего элемента должен быть меньше размера стека

    stackPtr[top++] = value; // помещаем элемент в стек
}

// функция удаления элемента из стека
template <typename T>
inline T Stack<T>::pop()
{
    // проверяем размер стека
    assert(top > 0); // номер текущего элемента должен быть больше 0

    stackPtr[--top]; // удаляем элемент из стека
}

// функция возвращает n-й элемент от вершины стека
template <class T>
inline const T& Stack<T>::Peek(int nom) const
{
    //
    assert(nom <= top);

    return stackPtr[top - nom]; // вернуть n-й элемент стека
}

// вывод стека на экран
template <typename T>
inline void Stack<T>::printStack()
{
    for (int ix = top - 1; ix >= 0; ix--)
        cout << "|" << setw(4) << stackPtr[ix] << endl;
}

// вернуть размер стека
template <typename T>
inline int Stack<T>::getStackSize() const
{
    return size;
}

// вернуть указатель на стек (для конструктора копирования)
template <typename T>
inline T* Stack<T>::getPtr() const
{
    return stackPtr;
}

// вернуть размер стека
template <typename T>
inline int Stack<T>::getTop() const
{
    return top;
}

#endif // STACK_H

Или любые другие,вот ещё пару вариантов шаблонов

Stack.h

#include <iostream>
#include <cstdlib>
using namespace std;

// define default capacity of stack
#define SIZE 10

// Class for stack
template <class X>
class stack
{
    X* arr;
    int top;
    int capacity;

public:
    stack(int size = SIZE); // constructor

    void push(X);
    X pop();
    X peek();

    int size();
    bool isEmpty();
    bool isFull();

    // destructor
    ~stack() {
        delete[] arr;
    }
};

// Constructor to initialize stack
template <class X>
stack<X>::stack(int size)
{
    arr = new X[size];
    capacity = size;
    top = -1;
}

// function to add an element x in the stack
template <class X>
void stack<X>::push(X x)
{
    if (isFull())
    {
        cout << "OverFlow\nProgram Terminated\n";
        exit(EXIT_FAILURE);
    }

    cout << "Inserting " << x << endl;
    arr[++top] = x;
}

// function to pop top element from the stack
template <class X>
X stack<X>::pop()
{
    // check for stack underflow
    if (isEmpty())
    {
        cout << "UnderFlow\nProgram Terminated\n";
        exit(EXIT_FAILURE);
    }

    cout << "Removing " << peek() << endl;

    // decrease stack size by 1 and (optionally) return the popped element
    return arr[top--];
}

// function to return top element in a stack
template <class X>
X stack<X>::peek()
{
    if (!isEmpty())
        return arr[top];
    else
        exit(EXIT_FAILURE);
}

// Utility function to return the size of the stack
template <class X>
int stack<X>::size()
{
    return top + 1;
}

// Utility function to check if the stack is empty or not
template <class X>
bool stack<X>::isEmpty()
{
    return top == -1;   // or return size() == 0;
}

// Utility function to check if the stack is full or not
template <class X>
bool stack<X>::isFull()
{
    return top == capacity - 1; // or return size() == capacity;
}

Stack.h

#pragma once

template <typename T>
class Stack {
private:
    T* start; //указатель на стек
    int t; //положение вершины стека
    int size; //размер стека

public:
    class StackERR
    {
        int code;
    public:
        StackERR(int n = 0) : code(n) {}
        int getCode()
        {
            return code;
        }
    };

        //конструктор с параметром– размер стека
        Stack(int n = 10);
    ~Stack() { delete[] start; } //деструктор
    // операции
    void push(const T&); //в стек
    T pop(); //из стека
    T top() const; //вершина стека

        // проверки
        bool isEmpty() const { return t == -1; }
    //true, если стек пустой
    bool isFull() const { return t == size - 1; }
    //true, если стек полон
};


//конструктор
template < typename T>
Stack<T> ::Stack(int n)
{
    //«разумный» размер стека
    size = n > 0 && n < 1000 ? n : 10;
    start = new T[size];
    t = -1;
}

//помещение объекта в стек
template < typename T>
void Stack<T>::push(const T & x) {
    if (!isFull()) {
        start[++t] = x; //сдвигаем вершину
        return;
    }
    throw StackERR(1); //стек полон
}

//выталкивание элемента из стека
template < typename T>
T Stack<T>::pop() {
    if (!isEmpty()) {
        return start[t--];
        //взяли элемент, опустили вершину
    }
    throw StackERR(2); //в стеке нет элементов
}

//просмотр элемента из вершины стека
template < typename T>
T Stack<T>::top()const {
    if (!isEmpty()) {
        return start[t];
    }
    throw StackERR(2);
}