Кольцевой двусвязный список

#include <iostream>
#include <windows.h>
using namespace std;
struct   c
{
        int n;
    c *prev;
    c *next;
};
  
int main()
{
 
  system("cls");
  SetConsoleCP(1251);
  SetConsoleOutputCP(1251); 
  
  int A[6]={5,7,9,10,12,13};
  c *begin = NULL;
  c *last = NULL;
  c *list = NULL;
  for (int i=0; i<6; i++)
    if (begin == NULL)
    {
           last = new c;
       begin = last;
       last->n = A[i];
       last->prev = NULL;
       last->next = NULL;
       list = last; 
    }
    else 
    { 
           last = new c;
       list->next = last;
       last->n = A[i];
       last->prev = list;
       last->next = NULL;
       list = last;
    }
 
    list = begin;
    cout <<"Список = \n";
    while (list) 
    {
      cout<<list->n<<"\n";
      list = list->next; 
    }
 
    list = begin;
    while (begin) 
    {
      list = begin;
      begin = list->next;
      delete list;
    }
    
    delete begin;
 
    return 0;    
}

#include <iostream>
 
struct Node {
  int data;
  Node *prev;
  Node *next;
};
 
class CircularDoublyLinkedList {
public:
private:
  Node *m_head;
  size_t m_size;
 
public:
  CircularDoublyLinkedList();
  ~CircularDoublyLinkedList();
  // WARNING: Мы не соблюли правило трёх/пяти
 
  bool isEmpty();
  void push(int data);
  int pop();
  size_t size();
  Node *getHead();
};
 
CircularDoublyLinkedList::CircularDoublyLinkedList()
    : m_head(nullptr)
    , m_size(0)
{
}
 
CircularDoublyLinkedList::~CircularDoublyLinkedList()
{
  while (!isEmpty()) {
    pop();
  }
}
 
bool CircularDoublyLinkedList::isEmpty()
{
  return (m_head == nullptr);
}
 
void CircularDoublyLinkedList::push(int data)
{
  if (isEmpty()) {
    m_head = new Node();
    m_head->data = data;
    m_head->prev = m_head;
    m_head->next = m_head;
    m_size = 1;
  } else {
    Node *tmp = new Node();
    tmp->data = data;
    tmp->next = m_head;
    tmp->prev = m_head->prev;
    m_head->prev = tmp;
    tmp->prev->next = tmp;
    m_head = tmp;
    ++m_size;
  }
}
 
int CircularDoublyLinkedList::pop()
{
  int res;
  if (m_size > 1) {
    Node *tmp = m_head;
    m_head = tmp->next;
    tmp->prev->next = m_head;
    m_head->prev = tmp->prev;
    res = tmp->data;
    delete tmp;
    --m_size;
 
  } else if (m_size == 1) {
    res = m_head->data;
    delete m_head;
    m_head = nullptr;
    m_size = 0;
  } else {
    res = 0;
  }
  return res;
}
 
size_t CircularDoublyLinkedList::size()
{
  return m_size;
}
 
Node *CircularDoublyLinkedList::getHead()
{
  return m_head;
}
 
void print_nodes_data_forward(Node *node, size_t count)
{
  if (node) {
    std::cout << "Forward:  ";
    Node *tmp = node;
    for (size_t i = 0; i < count; ++i) {
      std::cout << tmp->data << " -> ";
      tmp = tmp->next;
    }
    std::cout << "...\n";
  } else {
    std::cerr << "ERROR: Empty!!!\n";
  }
}
 
void print_nodes_data_backward(Node *node, size_t count)
{
  if (node) {
    std::cout << "Backward: ";
    Node *tmp = node;
    for (size_t i = 0; i < count; ++i) {
      std::cout << tmp->data << " -> ";
      tmp = tmp->prev;
    }
    std::cout << "...\n";
  } else {
    std::cerr << "ERROR: Empty!!!\n";
  }
}
 
int main()
{
  CircularDoublyLinkedList circ;
 
  for (size_t i = 1; i < 6; ++i) {
    std::cout << "Push: " << i << "\n";
    circ.push(i);
    print_nodes_data_forward(circ.getHead(), 10);
    print_nodes_data_backward(circ.getHead(), 10);
  }
  for (size_t i = 1; i < 6; ++i) {
    int n = circ.pop();
    std::cout << "Pop: " << n << "\n";
    print_nodes_data_forward(circ.getHead(), 10);
    print_nodes_data_backward(circ.getHead(), 10);
  }
  return 0;
}