Thread: Queue with a circular array... nitpick !

Another one... Works fine(at least on my test cases); but .. for a second opinion.
Is there a better way to represent the [warping / wrapping (not sure which!)] of the queue ?

(Press Ctrl+W or Alt+F4 or the Big Red Button if terribly annoyed at these posts :P )

Code:

namespace mm
{
enum queue_error{overflow, underflow, beheaded};


template<typename T, int Size>
class queue
{
private:
    T mem[Size];
    int head_ptr;
    int tail_ptr;
    
    inline int diff(int pt1, int pt2) 
        {return pt1-pt2 >=0 ? pt1-pt2 : pt1+Size-pt2 ;}
    // pt1 - pt2 .. keeping 'circular' logic in mind
    inline void increment(int& ptr) { ptr++; ptr%=Size; };
    // incrementing, and wrapping around when necessary 
public:
    queue():head_ptr(1),tail_ptr(0){};
    void push(const T& in)
    {
        if(this->full()) throw(overflow);
        increment(tail_ptr);        
        mem[tail_ptr] = in ; 
    };
    
    void pop()
    {
        if(this->empty()) throw(underflow);
        increment(head_ptr);
    };
    
    T& head()
    {
        if(this->empty())throw(beheaded);
        return mem[head_ptr];
    };
    
    int size()
    {
        if(this->empty())return 0;
        else return diff(tail_ptr,head_ptr)+1;
    };
    
    bool empty(){return diff(head_ptr,tail_ptr)==1;};
    bool full(){return diff(head_ptr,tail_ptr) ==2;};
};
    
}