从空队列中删除元素

我正在编写抽象数据类型的优先级队列，作为大学的任务，其他人将使用它。我的类dequeue中有一个函数，它删除队列中的第一个元素并返回该元素的数据。但是，当我试图从一个空队列中删除一个元素时，程序会崩溃。我在这里该怎么办？

如果有帮助的话，下面是代码：

#ifndef PRIORITYQUEUE_H
#define PRIORITYQUEUE_H
#include <iostream>
using namespace std;
const int max_queue_items = 1000;
template<class T>
struct node{
    T data;
    int priority;
    node *next;
};
template<class T>
class PriorityQueue
{
    public:
        /*
            Constructor that creates an empty queue.
        */
        PriorityQueue(){
            head = NULL;
            size = 0;
        }
        /*
            Adds an element to the queue.
            Params:
            data - data of the element
            priority - priority of the element
        */
        bool is_empty(){
            if (size == 0){
                return true;
            }
            return false;
        }
        bool is_full(){
            if (size == max_queue_items){
                return true;
            }
            return false;
        }
        /*
            Adds an element to thq queue.
            It gets inserted before the first element with
            lower priority.
        */
        void enqueue(T data, int priority){
            node<T> * previous = NULL;
            node<T> * now = head;
            while (now != NULL && now->priority >= priority){
                previous = now;
                now = now->next;
            }
            node<T> * new_element = new node<T>;
            new_element->data = data;
            new_element->priority = priority;
            new_element->next = now;
            if (previous == NULL){
                head = new_element;
            } else {
                previous->next = new_element;
            }
            size++;
        }
        /*
            Removes the first element in the queue
        */
        T dequeue(){
            T data;
            if (!is_empty()){
                node<T> * now = head;
                data = now->data;
                head = head->next;
                delete now;
                size--;
            }
            return data;
        }
        /*
            Returns the priority of the first element.
            It's always the highest priority in the queue.
        */
        int get_first_priority(){
            return head->priority;
        }
        /*
            Returns the data of the first element in the queue.
        */
        T get_first_value(){
            if (is_empty())
                throw 0;
            return head->data;
        }
        /*
            Returns the number of elements in the queue.
        */
        int get_size(){
            return size;
        }
        /*
            Deletes the whole queue from the memory.
        */
        void flush(){
            node<T> * now;
            while (head != NULL){
                now = head;
                head = head->next;
                delete now;
                size--;
            }
        }
        /*
            Prints the whole queue following this format:
            data(priority)
        */
        void print(){
            node<T> * now = head;
            while (now != NULL){
                cout << now->data << "(" << now->priority << ")" << endl;
                now = now->next;
            }
        }
    private:
        node<T> * head; // Pointer to the head of the queue
        int size; // Number of elements in the queue
};
#endif // PRIORITYQUEUE_H