Шаблонная циклическая очередь

#pragma once
#include <iostream>
#define QUEUE_IS_EMPTY -1
 
#define QUEUE_TEMPLATE template <typename T, const int CAPACITY> // Использование шаблонных параметров
 
QUEUE_TEMPLATE
class Queue {
private:
    int firstElementPos; // Первый элемент очереди ("QUEUE_IS_EMPTY" - очередь пуста)
    int lastElementPos; // Последний элемент очереди ("QUEUE_IS_EMPTY" - очередь пуста)
 
    // Статическое выделение памяти
    T queueOfElements[CAPACITY] = {};   // Массив для хранения данных
 
public:
    Queue(); // Конструктор
 
    Queue(const Queue& other); // Конструктор копирования
 
    Queue& operator=(const Queue& other); // Оператор присваивания
 
    bool queueIsFull(); // Проверка заполненности очереди
 
    bool queueIsEmpty(); // Проверка очереди на отсутствие элементов
 
    bool addToQueue(T newElement); // Добавление элемента в очередь true - удачно, false - очередь заполнена
 
    T takeFromQueue(); // Получение элемента из очереди
 
    int printQueueSize(); // Возвращает текущее количество элементов в очереди
 
    ~Queue(); // Деструктор
 
};

#include "Queue.h"
 
// Конструктор
QUEUE_TEMPLATE
Queue<T, CAPACITY>::Queue() : firstElementPos(QUEUE_IS_EMPTY), lastElementPos(QUEUE_IS_EMPTY)
{
    // ctor
}
 
// Конструктор копирования
QUEUE_TEMPLATE
Queue<T, CAPACITY>::Queue(const Queue& other) : firstElementPos(other.firstElementPos), lastElementPos(other.lastElementPos)
{
    if (lastElementPos != QUEUE_IS_EMPTY) // Если присваивается не пустая очередь
    {
        if (lastElementPos == firstElementPos) // Очередь содержит всего один элемент
        {
            this->queueOfElements[firstElementPos] = other.queueOfElements[firstElementPos];
        }
        else if (lastElementPos > firstElementPos) // Последний элемент в массиве позже первого
        {
            for (auto i = firstElementPos; i <= lastElementPos; i++)
            {
                this->queueOfElements[i] = other.queueOfElements[i];
            }
        }
        else // lastElementPos < firstElementPos // Последний элемент в массиве раньше первого
        {
            for (auto i = 0; i <= lastElementPos; i++) // 0 - last
            {
                this->queueOfElements[i] = other.queueOfElements[i];
            }
            for (auto i = firstElementPos; i <= CAPACITY; i++) // first - CAPACITY
            {
                this->queueOfElements[i] = other.queueOfElements[i];
            }
        }
    }
}
 
// Оператор присваивания
QUEUE_TEMPLATE
Queue<T, CAPACITY>& Queue<T, CAPACITY>::operator=(const Queue& other)
{
    if (&other != this)
    {
        this->firstElementPos = other.firstElementPos;
        this->lastElementPos = other.lastElementPos;
 
        if (lastElementPos != QUEUE_IS_EMPTY) // Если присваивается не пустая очередь
        {
            if (lastElementPos == firstElementPos) // Очередь содержит всего один элемент
            {
                this->queueOfElements[firstElementPos] = other.queueOfElements[firstElementPos];
            }
            else if (lastElementPos > firstElementPos) // Последний элемент в массиве позже первого
            {
                for (auto i = firstElementPos; i <= lastElementPos; i++)
                {
                    this->queueOfElements[i] = other.queueOfElements[i];
                }
            }
            else // lastElementPos < firstElementPos // Последний элемент в массиве раньше первого
            {
                for (auto i = 0; i <= lastElementPos; i++) // 0 - last
                {
                    this->queueOfElements[i] = other.queueOfElements[i];
                }
                for (auto i = firstElementPos; i <= CAPACITY; i++) // first - CAPACITY
                {
                    this->queueOfElements[i] = other.queueOfElements[i];
                }
            }
        }
    }
    return *this;
}
 
// queueIsFull
QUEUE_TEMPLATE
bool Queue<T, CAPACITY>::queueIsFull() // Проверка заполненности очереди
{
    if ((firstElementPos == 0 && lastElementPos == CAPACITY - 1) || (firstElementPos == lastElementPos + 1))
    {
        return true; // Очередь заполнена
    }
    else
    {
        return false; // Очередь имеет свободное место
    }
}
 
// queueIsEmpty
QUEUE_TEMPLATE
bool Queue<T, CAPACITY>::queueIsEmpty() // Проверка очереди на отсутствие элементов
{
    if (firstElementPos == QUEUE_IS_EMPTY)
    {
        return true; // Очередь пустая
    }
    else
    {
        return false; // Очередь содержит элементы
    }
}
 
// addToQueue
QUEUE_TEMPLATE
bool Queue<T, CAPACITY>::addToQueue(T newElement) { // Добавление элемента в очередь true - удачно, false - очередь заполнена
    if (queueIsFull())
    {
        return false; // Очередь заполнена
    }
    else
    {
        if (queueIsEmpty())
        {
            firstElementPos = 0; // Если очередь пустая - заполнение с 0-го элемента
        }
        auto newLastElem = (lastElementPos + 1) % CAPACITY; // Новая позиция последнего элемента
        queueOfElements[newLastElem] = newElement;          // Запись нового элемента в очередь
        lastElementPos = newLastElem;                       // Запись новой позиции последнего элемента
 
        return true; // Элемент добавлен в очередь
    }
}
 
// takeFromQueue
QUEUE_TEMPLATE
T Queue<T, CAPACITY>::takeFromQueue() { // Получение элемента из очереди
    if (queueIsEmpty())
    {
        return NULL; // Очередь пустая
    }
 
    T element;
    element = queueOfElements[firstElementPos]; // Запись первого элемента из очереди
 
    if (firstElementPos == lastElementPos)
    {
        firstElementPos = QUEUE_IS_EMPTY;   // Если выдан последний элемент в очереди
        lastElementPos = QUEUE_IS_EMPTY;    // возврат к "пустому" состоянию
    }
    else
    {
        firstElementPos = (firstElementPos + 1) % CAPACITY; // Если в очереди остались элементы - сдвиг позиции первого
    }
    return element; // Передача первого элемента из очереди
}
 
// printQueueSize
QUEUE_TEMPLATE
int Queue<T, CAPACITY>::printQueueSize() { // Возвращает текущее количество элементов в очереди
 
    if (queueIsEmpty()) {
        return QUEUE_IS_EMPTY; // Очередь пустая
    }
    else
    {
        // Подсчет количества элементов
        if (lastElementPos >= firstElementPos)
        {
            return lastElementPos - firstElementPos + 1;
        }
        else
        {
            return lastElementPos - firstElementPos + 1 + CAPACITY;
        }
    }
}
 
// Деструктор
QUEUE_TEMPLATE
Queue<T, CAPACITY>::~Queue()
{
    // dtor
}

#include <iostream>
 
#include "Queue.h"
#include "Queue.cpp"
 
int main() {
 
    Queue<int, 5> q; // Создание экземпляра
 
    std::cout << q.takeFromQueue() << std::endl; // Попытка взять из очереди. False, потому что очередь пуста
 
    q.addToQueue(1); // Заполнение очереди
    q.addToQueue(2);
    q.addToQueue(3);
    q.addToQueue(4);
    q.addToQueue(5);
 
    q.addToQueue(6); // Невозможно поставить в очередь, потому что firstElementPos == 0 && lastElementPos == CAPACITY - 1
 
    int elem = q.takeFromQueue();
 
    if (elem != NULL)
        std::cout << "Deleted Element is " << elem << std::endl;
 
    q.printQueueSize();
 
    q.addToQueue(7);
 
    q.printQueueSize();
 
    q.addToQueue(8); // Невозможно поставить в очередь, потому что firstElementPos == lastElementPos + 1
 
    // ================================================================== //
    std::cout << "// ---------- Сopy constructor ---------- //" << std::endl;
    // ================================================================== //
 
    Queue<int, 5> q1{ q }; // Использование конструктора копирования
 
    q1.printQueueSize();
 
    // ================================================================== //
    std::cout << "// ---------- Assignment operator ---------- //" << std::endl;
    // ================================================================== //
 
    Queue<int, 5> b;
 
    b.printQueueSize();
 
    b.addToQueue(0);
    b.addToQueue(9);
    b.addToQueue(8);
    b.addToQueue(7);
    b.addToQueue(6);
 
    b = q; // Использование оператора присваивания копирования
 
    b.printQueueSize();
 
    return 0;
}

element = queueOfElements[firstElementPos]; // Запись первого элемента из очереди
queueOfElements[firstElementPos].~T();