He desarrollado una clase Pila y una Clase cola para estudiar de cara a la universidad y se me ha ocurrido publicarla aquí, ya que estoy viendo publicaciones en las que se hacen preguntas sobre la implementación de estas clases y podrían ayudar a más de uno. Si alguien encuentra algún error que lo comente, por favor.

Aquí los archivos:

Stack.h

#include <cstddef>
 
template <class T>
class Stack
{
  private:
    struct Node
    {
      Node* nextNode;
      T data;
    };
 
    Node* topNode = NULL;
    int dataSize = 0;
 
    static Node* copyNode(Node* node)
    {
      Node* newNode = NULL;
      if (node)
      {
	newNode = new Node;
	newNode->data = node->data;
	newNode->nextNode = copy(node->nextNode);
      }
      return newNode;
    }
    static void deleteNode(Node* node)
    {
      if (node)
      {
	deleteNode(node->nextNode);
	delete node;
      }
    }
 
  public:
    Stack();
    Stack(const Stack& original);
    ~Stack();
 
    T top() const;
    bool empty() const;
    int size() const;
 
    void push(const T& data);
    void pop();
    void clear();
 
    Stack& operator =(const Stack& original);
};
 
template <class T>
Stack<T>::Stack() {}
 
template <class T>
Stack<T>::Stack(const Stack &original)
{
  if (this != &original)
  {
    dataSize = original.dataSize;
    topNode = copy(original.topNode);
  }
}
 
template <class T>
Stack<T>::~Stack()
{
  deleteNode(this->topNode);
}
 
template <class T>
Stack<T>& Stack<T>::operator =(const Stack& original)
{
  if (this != &original)
  {
    dataSize = original.dataSize;
    deleteNode(topNode);
    topNode = copyNode(original.topNode);
  }
  return *this;
}
 
template <class T>
T Stack<T>::top() const
{
  return topNode->data;
}
 
template <class T>
void Stack<T>::push(const T& data)
{
  Node* newTop = new Node;
  newTop->data = data;
  newTop->nextNode = topNode;
  topNode = newTop;
 
  dataSize = dataSize + 1;
}
 
template <class T>
void Stack<T>::pop()
{  
  Node* auxNode = topNode;
  topNode = topNode->nextNode;
  delete auxNode;
 
  dataSize = dataSize - 1;
}
 
template <class T>
bool Stack<T>::empty() const
{
  return (topNode == NULL);
}
 
template <class T>
int Stack<T>::size() const
{
  return dataSize;
}
 
template <class T>
void Stack<T>::clear()
{
  deleteNode(topNode);
  topNode = NULL;
  dataSize = 0;
}

Queue.h

#include <cstddef>
 
template <class T>
class Queue
{
  private:
    struct Node
    {
      T data;
      Node* prevNode;
    };
 
    int dataSize;
    Node* frontNode;
    Node* lastNode;
 
    static Node* copyNode(Node* node, Node* last)
    {
      Node* newNode = NULL;
      if(node)
      {
	newNode = new Node;
	newNode->data = node->data;
	newNode->prevNode = copyNode(node->prevNode);
	if (newNode->nextNode == NULL) last = newNode;
      }
      return newNode;
    }
 
    static void deleteNode(Node* node)
    {
      if(node)
      {
	deleteNode(node->prevNode);
	delete node;
      }
    }
 
  public:
    Queue();
    Queue(const Queue& original);
    ~Queue();
 
    T front() const;
    bool empty() const;
    int size() const;
 
    void push(const T &data);
    void pop();
    void clear();
 
    Queue& operator =(const Queue& original);
};
 
template <class T>
Queue<T>::Queue()
{
  dataSize = 0;
  frontNode = NULL;
  lastNode = NULL;
}
 
template <class T>
Queue<T>::Queue(const Queue& original)
{
  if (this != &original)
  {
    dataSize = original.dataSize;
    frontNode = copyNode(original.frontNode);
  }
}
 
template <class T>
Queue<T>::~Queue()
{
  deleteNode(frontNode);
}
 
template <class T>
T Queue<T>::front() const
{
  return frontNode->data;
}
 
template <class T>
bool Queue<T>::empty() const
{
  return (frontNode == NULL);
}
 
template <class T>
int Queue<T>::size() const
{
  return dataSize;
}
 
template <class T>
void Queue<T>::push(const T &data)
{ 
  Node* newNode = new Node;
  newNode->data = data;
  newNode->prevNode = NULL;
  if (!frontNode) frontNode = newNode;
  else lastNode->prevNode = newNode;
  lastNode = newNode;
 
  dataSize = dataSize + 1;
}
 
template <class T>
void Queue<T>::pop()
{ 
  Node* aux = frontNode;
  frontNode = frontNode->prevNode;
  delete aux;
 
  dataSize = dataSize - 1;
}
 
template <class T>
void Queue<T>::clear()
{ 
  deleteNode(frontNode);
  frontNode = NULL;
  lastNode = NULL;
  dataSize = 0;
}
 
template <class T>
Queue<T>& Queue<T>::operator =(const Queue& original)
{
  if (this != &original)
  {
    dataSize = original.dataSize;
    deleteNode(frontNode);
    frontNode = copyNode(original.frontNode);
  }
  return *this;
}

Saludos.