Можно ли считать односвязный список стеком?

#include <iostream>
 
template<typename T>
struct Node
{
   Node(const T& val, Node* n = 0):
   value(val), next(n)
   {
   }
   T value;
   Node* next;
};
 
template<typename T>
class Stack
{
public:
   Stack():head(0), top_(head)
   {
   }
   void push(const T& value)
   {
      Node<T>* tmp = new Node<T>(value);
      if (!top_)
      {
         top_ = head = tmp;
      }
      else
      {
         tmp->next = top_;
         top_ = tmp;
      }
   }
   const T top() const
   {
      return top_->value;
   }
   bool empty() const { return !top_; }
   void pop()
   {
      Node<T>* tmp = top_;
      top_ = top_->next;
      delete tmp;
   }
private:
   Node<T>* head;
   Node<T>* top_;
};
 
int main()
{
   Stack<int> stck;
   stck.push(1);
   stck.push(2);
   stck.push(3);
   stck.push(4);
   while (!stck.empty())
   {
      std::cout << stck.top() << std::endl;
      stck.pop();
   }
}

      /**
       *  Returns a read/write reference to the data at the first
       *  element of the %stack.
       */
      reference
      top()
      {
    __glibcxx_requires_nonempty();
    return c.back();
      }
 
      /**
       *  Returns a read-only (constant) reference to the data at the first
       *  element of the %stack.
       */
      const_reference
      top() const
      {
    __glibcxx_requires_nonempty();
    return c.back();
      }
 
      /**
       *  @brief  Add data to the top of the %stack.
       *  @param  x  Data to be added.
       *
       *  This is a typical %stack operation.  The function creates an
       *  element at the top of the %stack and assigns the given data
       *  to it.  The time complexity of the operation depends on the
       *  underlying sequence.
       */
      void
      push(const value_type& __x)
      { c.push_back(__x); }