SQUEW - a queue made from 2 stacks

squew.cpp

#include <vector>
#include <stack>
#include <initializer_list>

#include <iostream>
#include <string>
#include <stdexcept>
#include <future>
#include <assert.h>


template <typename T>
class CrappyQueue
{
private:
    using Stack = std::stack<T>;
    Stack s1;
    Stack s2;

public:
    CrappyQueue () { }
    CrappyQueue (const std::initializer_list<T>& l)
    {
        for (const auto& el : l)
        {
            enqueue(el);
        }
    }
    virtual ~CrappyQueue () { }

    void enqueue(const T& val)
    {
        s1.push(val);
    }

    T dequeue()
    {
        refill_if_queue_empty();
        const auto v = s2.top();
        s2.pop();
        return v;
    }

    T peek()
    {
        refill_if_queue_empty();
        if(s2.empty())
        {
            const auto msg = std::string("Error: ") + "queue is empty.";
            throw std::runtime_error(msg);
        }
        return s2.top();
    }

protected:
    void refill_if_queue_empty()
    {
        if (s2.empty())
        {
            pour(s1, s2);
            assert(s1.empty());
        }
    }

    // pours s1 into s2
    void pour(Stack& _s1,
              Stack& _s2)
    {
        while(!_s1.empty())
        {
            _s2.push(_s1.top());
            _s1.pop();
        }
    }
};

void test_crappy_queue()
{
    {
        CrappyQueue<int> queue;
        try {
            cout << queue.peek() << endl;
            assert(false); // did not throw exception as expected
        } catch (std::exception& e) {
            assert(e.what() == std::string("Error: ") + "queue is empty.");
        }
    }

    {
        CrappyQueue<int> queue;
        queue.enqueue(10);
        queue.enqueue(20);
        queue.enqueue(30);
        queue.enqueue(40);

        assert(queue.peek() == 10);
        assert(queue.dequeue() == 10);
        assert(queue.dequeue() == 20);
        assert(queue.dequeue() == 30);
        assert(queue.dequeue() == 40);
        try {
            cout << queue.peek() << endl;
            assert(false); // did not throw exception as expected
        } catch (std::exception& e) {
            assert(e.what() == std::string("Error: ") + "queue is empty.");
        }
    }

    {
        CrappyQueue<int> queue = {1,2,3,4,5};
        queue.enqueue(1000);
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        assert(queue.dequeue() == 1000);
    }

    {
        CrappyQueue<CrappyQueue<int>> queues = {
            CrappyQueue<int> {1,2,3,4,5},
            CrappyQueue<int> {10, 20, 30, 40},
        };
        queues.enqueue({-1,-2,-3,-4});
        auto q1 = queues.dequeue();
        assert(q1.dequeue() == 1);
        assert(q1.dequeue() == 2);
        assert(q1.dequeue() == 3);
    }
}


int main()
{
    test_crappy_queue();
    return 0;
}