Стек адаптирован из Deque Pointer?

Для моего курса меня попросили создать класс Stack, который хранит свои элементы в контейнере STL (но не в контейнере стека STL).

Требования:

• должен иметь возможность хранить элементы произвольного типа
• каждый экземпляр принимает вставки, если в системе достаточно свободной памяти
• должен быть в пространстве имен cop4530
• необходимо использовать большинство методов и перегрузок операторов, указанных в заголовочном файле ниже
  (не назад (), + = op, [] ops)
• методы / функции и т. д., объявленные в .h и реализованные в отдельном .hpp

Затем я использую стек с другой созданной мной программой, которая меняет арифметику инфиксной нотации на постфиксную и оценивает ее, если все элементы сопоставимы.

Мой профессор дал пример заголовочного файла того, как это может выглядеть, как показано ниже.

Почему он использует деку указатель??
Я искал и нашел много случаев, когда люди адаптируют контейнер STL к стеку, но никогда не объяснял контейнер STL как указатель на стек. Может ли кто-нибудь объяснить преимущества этого по сравнению с использованием не указателя, если таковые имеются? Примеры помощи

Пример файла декларации .h

#ifndef COP4530_STACK_H
#define COP4530_STACK_H

#include <iostream>
#include <deque>

namespace cop4530
{

template <typename T>
class Stack;

//----------------------------------
//     Stack<T>
//----------------------------------

template <typename T>
class Stack
{
public:
// Constructor, Copy-constructor and destructor
Stack  ();
Stack  (const Stack<T>&);
Stack  (Stack<T> &&);
~Stack ();

// member operators
Stack<T>& operator =  (const Stack<T>&);
Stack<T> & operator=(Stack<T> &&);
Stack<T>& operator += (const Stack<T>&);
const T&         operator [] (int) const;
T&               operator [] (int);

// other methods
int   size        () const;
int   capacity    () const;

// Container class protocol
bool         empty     () const;
void         clear     ();
void         push      (const T&);
void         push      (T &&);
void         pop       ();
T&           top       ();
const T&     top       () const;
T&           back      ();// Display methods
void print    (std::ostream& os, char ofc = ' ') const;

protected:
std::deque<T>  *mystack;   // pointer to the stack.
//std::deque<T>   mystack;   //WHY NOT THIS???

} ;

// operator overloads
template < class T >
std::ostream& operator << (std::ostream& os, const Stack<T>& a);

template < class T >
bool      operator == (const Stack<T>&, const Stack<T>&);

template < class T >
bool      operator != (const Stack<T>&, const Stack<T>&);

template < class T >
bool      operator <= (const Stack<T>&, const Stack<T>&);

#include "stack.hpp"
}   // namespace cop4530
#endif

Пример реализации .hpp

#ifndef COP4530_STACK_HPP
#define COP4530_STACK_HPP

//----------------------------------------
//     Stack<T>:: Implementations
//----------------------------------------

// operator overloads

template <typename T>
std::ostream& operator << (std::ostream& os, const Stack<T>& s)
{

}

template <typename T>
bool operator<=(const Stack<T>& s1, const Stack<T>& s2)
{

}

template <typename T>
bool operator == (const Stack<T>& s1, const Stack<T>& s2)
{

}

template <typename T>
bool operator != (const Stack<T>& s1, const Stack<T>& s2)
{

}

// public methods

template <typename T>
Stack<T>::Stack()
//Constructor
{

}

template <typename T>
Stack<T>::Stack(const Stack<T>& source)
//Copy-constructor
{

}template <typename T>
Stack<T>::Stack(Stack<T> && source)
{

}
template <typename T>
Stack<T>::~Stack()
// destructor
{

}

template <typename T>
Stack<T>& Stack<T>::operator = (const Stack<T>& source)
// assignment operator
{

}

template <typename T>
Stack<T>& Stack<T>::operator = (Stack<T> && source)
{

}

template <typename T>
Stack<T>& Stack<T>::operator += (const Stack<T>& source)
{

}

template <typename T>
const T& Stack<T>::operator [] (int i) const
// element operator
{

}

template <typename T>
T& Stack<T>::operator [] (int i)
// element operator
{

}

template <typename T>
bool Stack<T>::empty() const
{

}

template <typename T>
int Stack<T>::size() const
{

}

template <typename T>
void Stack<T>::push(const T& Val)
{

}

template <typename T>
void Stack<T>::push(T && Val)
{

}

template <typename T>
void Stack<T>::pop()
{

}

template <typename T>
void Stack<T>::clear()
{

}

template <typename T>
T&  Stack<T>::top()
{

}

template <typename T>
const T&  Stack<T>::top() const
{

}

template <typename T>
T&  Stack<T>::back()
{

}

template <typename T>
void Stack<T>::print(std::ostream& os, char ofc) const
{

}

#endif