c++ - c++中动态分配的链表。发生异常后如何防止内存泄漏？

Question

我喜欢用c++实现链表，添加新节点时动态分配，如果某些分配失败，我希望我的程序停止执行。

“新节点”失败后抛出异常，因此我必须在异常处理程序中显式调用析构函数。我该如何处理这种情况以防止内存泄漏？这是我编写的代码

链表.h

#pragma once
#include <iostream>
#include <string.h>
using namespace std;

class LinkedList
{
public:
    class Iterator; 
private:
    class Node
    {
        friend class Iterator;
        friend class LinkedList;
        char* m_word;
        Node *m_next;
        Node(const char* word,Node* next = NULL,Node* prev = NULL);
        ~Node();
    };
    Node *m_head,*m_tail;
    size_t m_num;
public:
    LinkedList():m_head(NULL),m_tail(NULL),m_num(0){};
    ~LinkedList();
    LinkedList& addFirst(const char* word);
    LinkedList& addLast(const char* word);
    Iterator erase(Iterator& it);
    Iterator begin();
    Iterator end();
    Iterator find(const char* word);
    size_t size()const{return m_num;};
    void print();

    friend class Iterator;
    class Iterator
    {
        LinkedList& m_list;
        Node *m_prev,*m_cur;
        friend class LinkedList;
        void next();
        void setLast(){m_cur = NULL,m_prev = m_list.m_tail;}
    public:
        Iterator(LinkedList& linkedList):m_list(linkedList),m_prev(NULL),m_cur(linkedList.m_head){}
        Iterator& operator++();
        char* operator*();
        bool operator != (Iterator& it){return (m_cur != it.m_cur || m_prev != it.m_prev);}
    };
};

链表.cpp

#include "LinkedList.h"


LinkedList::Node::Node(const char* word,LinkedList::Node* prev,LinkedList::Node *next)
{
    char* tmpWord = new char[strlen(word)+1];
    strcpy(tmpWord,word);
    m_word = tmpWord;
    m_next = next;
    if(prev != NULL)
        prev->m_next = this;
}
LinkedList::Node::~Node()
{
    delete[] m_word;
}

LinkedList::~LinkedList(void)
{
    for(Iterator it = begin();it != end();)
        erase(it);
}
LinkedList& LinkedList::addFirst(const char* word)
{
    Node* node = new Node(word,NULL,m_head);
    m_head = node;
    if(m_tail == NULL)
        m_tail = m_head;
    ++m_num;
    return *this;
}
LinkedList& LinkedList::addLast(const char*word)
{
    if(m_head == NULL)
        addFirst(word);
    else
    {
        Node* node = new Node(word,m_tail,NULL);
        m_tail = node;
    }
    ++m_num;
    return *this;
}
LinkedList::Iterator LinkedList::begin()
{
    Iterator it(*this);
    return it;
}
LinkedList::Iterator LinkedList::end()
{
    Iterator it(*this);
    it.setLast();
    return it;
}
LinkedList::Iterator LinkedList::erase(LinkedList::Iterator& it)
{
    if(it.m_cur != NULL)
    {
        Node* tmp = it.m_cur;
        if(it.m_prev != NULL)
            it.m_cur = it.m_prev->m_next = tmp->m_next;
        else
            it.m_cur = it.m_list.m_head = tmp->m_next;
        if(tmp == it.m_list.m_tail)
            it.m_list.m_tail = NULL;
        delete tmp;
        --m_num;
    }
    return it;
}
LinkedList::Iterator LinkedList::find(const char* word)
{
    Iterator it = begin();
    for(;it != end();++it)
    {
        if(!strcmp(it.m_cur->m_word,word))
            break;
    }
    return it;
}

void LinkedList::Iterator::next()
{
    if(m_cur != NULL)
    {
        m_prev = m_cur;
        m_cur = m_cur->m_next;
    }
    else
        m_prev = NULL;
    return;
}
void LinkedList::print()
{
    for(Iterator it = begin();it !=end();++it)
        cout << it.m_cur->m_word;
}
LinkedList::Iterator& LinkedList::Iterator::operator ++()
{
    next();
    return *this;
}
char* LinkedList::Iterator::operator *()
{
    return m_cur->m_word;
}

//int main()
//{
//  LinkedList ll;
//  ll.addFirst("1");
//  ll.addFirst("2");
//  ll.addLast("3");
//  ll.addLast("4");
//  LinkedList::Iterator it = ll.find("5");
//  return 0;
//}

Answer 1

After the "new Node" fails the exception is thrown.

so do I have to call the destructor explicitly in the exception handler.

没有。如果构造函数没有完成，则不能调用析构函数(对象从未创建)。

how can I deal with this situation in order to prevent memory leak?

如果在 new (std::bad_alloc) 中抛出异常，那么您无需执行任何操作。

如果从构造函数中抛出异常。然后每个完全构造的成员都会自动调用其析构函数。所以你不需要担心普通成员(member)。如果您的任何成员是指针(已在构造函数中初始化)，那么您需要确保将它们删除(这就是为什么您不希望对象中有 RAW 指针(您需要智能指针))。

这么说。您没有使用智能指针，但我看不到任何明显的泄漏。

但是你的类中有一个 RAW 指针是拥有的。您还没有读过 3 的规则(查找)。目前因为您不遵守规则 3，以下代码将崩溃。

void myCode()
{
    LinkedList    list1;
    list1.addFirst("Martin");

    LinkedList    list2(list1);
}