Динамически размещаемый связанный список в c ++. Что делать после исключения, чтобы предотвратить утечку памяти?

Question

Мне нравится реализовывать связанный список в c ++, при добавлении нового узла я его динамически распределяю, если при некотором выделении происходит сбой, я бы хотел, чтобы моя программа остановила выполнение.

После того, как «новый узел» завершил работу с исключениемвыбрасывается, поэтому я должен явно вызывать деструктор в обработчике исключений.Как я могу справиться с этой ситуацией, чтобы предотвратить утечку памяти?Вот мой код, который я написал

LinkedList.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);}
    };
};

LinkedList.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

После сбоя «нового узла» выдается исключение.

, поэтому я должен явно вызывать деструктор в обработчике исключений.

Нет.Если конструктор не завершил работу, вы не можете вызвать деструктор (объект никогда не создавался).

как мне справиться с этой ситуацией, чтобы предотвратить утечку памяти?

Если исключение выдается в new (std :: bad_alloc), то вам ничего не нужно делать.

Если исключение выдается из конструктора.Тогда каждому полностью сконструированному члену будет автоматически вызван его деструктор.Так что вам не нужно беспокоиться о нормальных членах.Если какой-либо из ваших членов является указателями (которые были инициализированы в конструкторе), то вам нужно убедиться, что они удалены (именно поэтому вы не хотите, чтобы RAW-указатели были в вашем объекте (вам нужны умные указатели)).

Сказав это.Вы не используете умные указатели, но я не вижу очевидных утечек.

Но у вас есть RAW-указатель в вашем классе, который принадлежит.Вы не читали о правиле 3 (посмотрите его).В настоящее время, поскольку вы не соблюдаете правило 3, следующий код завершится сбоем.

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

    LinkedList    list2(list1);
}

Answer 2

Если new дает сбой, вам не нужно беспокоиться об утечке памяти, потому что вы еще ничего не выделили. Вы можете просто зарегистрировать это сообщение об ошибке, если необходимо, и продолжить работу с существующим связанным списком.

Answer 3

Я не вижу там никакого обработчика исключений. Ответ iammilind справедливый, но даже если вы не хотите регистрировать ошибку, вы должны написать обработчик исключения, потому что, если это не так, исключение переходит в более высокий контекст, оно может остановить вашу программу с хорошо известным сообщением, которое Вы можете увидеть в отладчиках: НЕПРАВИЛЬНОЕ ИСКЛЮЧЕНИЕ в .... Я подозреваю, что вы подумали об этом под термином утечка памяти.