PV913StaticSimpleQueueTemplate

#include <iostream>

template <typename ElemT, int sizeP>
class Queue
{
    ElemT storage[sizeP];
    int backPosition;
    static const int emptyQueue{ -1 };
public:
    Queue() : backPosition{ emptyQueue } {};
    int size() const { return sizeP; };
    bool empty() const { return backPosition == emptyQueue; };
    bool full() const { return backPosition == sizeP - 1; };
    const ElemT& front() const { return storage[0]; };
    const ElemT& back() const { return storage[backPosition]; };

    bool push(const ElemT& elem)
    {
        if (!full())
        {
            storage[++backPosition] = elem;
            return true;
        }
        return false;
    }

    bool pop()
    {
        if (!empty())
        {
            for (int i{ 1 }; i <= backPosition; ++i)
            {
                storage[i - 1] = storage[i];
            }
            --backPosition;
            return true;
        }
        return false;
    }

    template <typename ElementType, int size>
    friend std::ostream& operator<<(std::ostream& out, const Queue<ElementType, size>& queue);
};

template <typename ElementType, int size>
std::ostream& operator<<(std::ostream& out, const Queue<ElementType, size>& queue)
{
    if (!queue.empty())
    {
        out << "[ ";
        for (int i{ 0 }; i <= queue.backPosition; ++i)
        {
            out << queue.storage[i] << ' ';
        }
        out << " ]\n";
    }
    else
    {
        out << "[empty]\n";
    }
    return out;
};


int main()
{
    Queue<int, 7> queue;
    std::cout << queue;

    std::cout << "Pushing into queue..\n";
    for (int i{ 0 }; !queue.full(); ++i)
    {
        queue.push(i);
        std::cout << queue.back() << '\n';
    };

    std::cout << "Popping from queue..\n";
    while (!queue.empty())
    {
        std::cout << queue.front() << ' ';
        queue.pop();
    }
    std::cout << queue.front() << ' ';
    std::cout << queue.front() << ' ';

}