Queue in C++.

queue.cpp

#include <cassert>
#include <cstring>
#include <iostream>

class Queue {
    int* storage;
    size_t front_;
    size_t back_;
    size_t size_;

public:
    Queue() {
        storage = new int[4];
        front_ = back_ = 0;
        size_ = 4;
    }

    ~Queue() { delete storage; }

    void enqueue(int elem) {
        if(size() == size_) {
            int* new_storage = new int[size_ * 2];
            for(size_t i = 0; i < size_; ++i) {
                new_storage[i] = storage[(front_ + i) % size_];
            }
            delete storage;
            storage = new_storage;
            front_ = 0;
            back_ = size_;
            size_ = size_ * 2;
        }
        storage[back_ % size_] = elem;
        ++back_;
    }

    int dequeue() {
        if(front_ == back_) throw "empty queue";
        return storage[front_++ % size_];
    }

    int front() {
        if(front_ == back_) throw "range error";
        return storage[front_ % size_];
    }

    int back() {
        if(front_ == back_) throw "range error";
        return storage[(back_ - 1) % size_];
    }

    size_t size() {
        return back_ - front_;
    }

    void debug() {
        std::cout << "storage: ";
        for(size_t i = 0; i < size_; ++i) {
            std::cout << storage[i] << " ";
        }
        std::cout << std::endl;
        std::cout << "front_: " << front_ << std::endl;
        std::cout << "back_: " << back_ << std::endl;
        std::cout << "size_: " << size_ << std::endl;
    }
};

int main() {
    Queue queue;

    try {
        queue.dequeue();
    } catch(const char* error) {
        assert(strcmp(error, "empty queue") == 0);
    }

    try {
        queue.front();
    } catch(const char* error) {
        assert(strcmp(error, "range error") == 0);
    }

    try {
        queue.back();
    } catch(const char* error) {
        assert(strcmp(error, "range error") == 0);
    }

    assert(queue.size() == 0);

    queue.enqueue(1);
    assert(queue.size() == 1);

    queue.enqueue(2);
    queue.enqueue(3);

    assert(queue.size() == 3);

    queue.enqueue(4);
    queue.enqueue(5);
    queue.enqueue(6);
    assert(queue.size() == 6);

    assert(queue.dequeue() == 1);
    assert(queue.dequeue() == 2);
    assert(queue.size() == 4);

    assert(queue.front() == 3);
    assert(queue.back() == 6);

    assert(queue.dequeue() == 3);
    assert(queue.dequeue() == 4);
    assert(queue.dequeue() == 5);
    assert(queue.dequeue() == 6);

    try {
        queue.dequeue();
    } catch(const char* error) {
        assert(strcmp(error, "empty queue") == 0);
    }

    try {
        queue.front();
    } catch(const char* error) {
        assert(strcmp(error, "range error") == 0);
    }

    try {
        queue.back();
    } catch(const char* error) {
        assert(strcmp(error, "range error") == 0);
    }

    return 0;
}