C++ 循环双链表内存释放

我在清理循环链表的内存时遇到了严重的问题。不过我想我理解这个问题。比如说，我的头指针有N个分配，而我的构建指针有N-1个分配。addback函数只能有一个整数，不能使用容器或向量

void Queue::addBack(int passed_Val)
{
    if (head == nullptr) //takes care of first node when list is empty
    {

        head = new QueueNode;//head is my building now
        cout<<"head is "<<sizeof(head)<<" bytes"<<endl;
        head->val = passed_Val;
        head->next = head;//this make an infinite loop
        head->prev = head;
        cout<<"node[0] mem allocated "<<head<<endl;

    }
    else 
    {
        //build next will always have N-1 address, where N = number of addresses
        //head points to. I don't want build to point to head when N=1
        //          have tempPtr point to old address                               
        QueueNode* tempPrev = head->prev;//this will always point to the last node added!   
        QueueNode* build = new QueueNode;
        build->next=head;
        cout<<"build is "<<sizeof(build)<<" bytes"<<endl;
        cout<<"node[1] mem allocated "<< build <<endl;
        cout<<"node[1] "<< head <<endl;
        build->val=passed_Val;

        build->next = head;
        head->prev = build;

        tempPrev->next = build;
        build->prev = tempPrev;

    }

void Queue:：addBack（int passed\u Val）
{
if（head==nullptr）//在列表为空时负责第一个节点
{
head=new QueueNode；//head现在是我的建筑
coutnext；
库特
这将销毁
deletePtr
引用的任何对象。紧接着：

            deletePtr =deletePtr->next;

这将尝试引用
deletePtr->next
。正如我们刚刚确定的那样，
deletePtr
的对象已被销毁，取消引用它将成为未定义的行为

这可能是所示代码的唯一问题，也可能不是。如果没有答案，就无法最终确定这一点，可能还有其他问题；但这肯定是其中之一。
为了补充@SamVarshavchick给出的答案，代码在这里有缺陷：

delete head;
while(deletePtr != head)  // <-- You are comparing deletePtr to a deleted pointer?

请注意，无需在函数开始时显式检查
head
是否为null，因为
while
循环将只在非null值上输入。
我是析构函数！下面是我如何解决它的

Queue::~Queue()
{
    int i=1;
    if(head !=nullptr)//needed because i don't want to deallocate head if it was never called
    {

        QueueNode* stop = head->prev;

        QueueNode* deletePtr = head->next;//tractor node[1]
        QueueNode* temp = head;// cutter            node[0]

        if(deletePtr ==head)// N=1
        {
            delete deletePtr;
        }
        else if(deletePtr == stop)//N=2
        {
             deletePtr = stop;
             delete deletePtr; 
             delete head;
        }
        else//N >=3
        {   
            while (temp != stop)//last node
            {
                delete temp;      //delete node[0]
                cout<<"temp "<<temp<<endl;
                cout<<"deletePtr "<<deletePtr<<endl;
                temp= deletePtr;// node[1]                                         
                deletePtr = deletePtr->next;//node[2]       
                cout<<"temp "<<temp<<endl;
                cout<<"deletePtr "<<deletePtr<<endl;


            }       
            delete stop;
        }//end N>=3

    }
}

Queue:：~Queue（）
{
int i=1；
if（head！=nullptr）//需要，因为如果从未调用过head，我不想取消分配它
{
QueueNode*stop=head->prev；
QueueNode*deletePtr=head->next；//拖拉机节点[1]
QueueNode*temp=head；//切割器节点[0]
如果（deletePtr==head）//N=1
{
删除deletePtr；
}
如果（deletePtr==stop）//N=2，则为else
{
deletePtr=停止；
删除deletePtr；
删除标题；
}
else//N>=3
{   
while（temp！=stop）//最后一个节点
{
delete temp；//删除节点[0]
可能常见的原因是破坏了。你在这样做吗？不能用给出的代码来说明。
delete head;
while(deletePtr != head)  // <-- You are comparing deletePtr to a deleted pointer?

Queue::~Queue()
{
    QueueNode* deletePtr = head;
    QueueNode* nextPtr = nullptr;
    while ( deletePtr )
    {
       nextPtr = deletePtr->next;
       delete deletePtr;
       deletePtr = nextPtr;
    }
}

Queue::~Queue()
{
    int i=1;
    if(head !=nullptr)//needed because i don't want to deallocate head if it was never called
    {

        QueueNode* stop = head->prev;

        QueueNode* deletePtr = head->next;//tractor node[1]
        QueueNode* temp = head;// cutter            node[0]

        if(deletePtr ==head)// N=1
        {
            delete deletePtr;
        }
        else if(deletePtr == stop)//N=2
        {
             deletePtr = stop;
             delete deletePtr; 
             delete head;
        }
        else//N >=3
        {   
            while (temp != stop)//last node
            {
                delete temp;      //delete node[0]
                cout<<"temp "<<temp<<endl;
                cout<<"deletePtr "<<deletePtr<<endl;
                temp= deletePtr;// node[1]                                         
                deletePtr = deletePtr->next;//node[2]       
                cout<<"temp "<<temp<<endl;
                cout<<"deletePtr "<<deletePtr<<endl;


            }       
            delete stop;
        }//end N>=3

    }
}