c+中动态分配的链表+；。异常后如何防止内存泄漏？ 我喜欢在C++中实现链表，同时添加新的节点i动态分配它， 如果某些分配失败，我希望我的程序停止执行

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

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

#pragma一次
#包括
#包括
使用名称空间std；
类链接列表
{
公众：
类迭代器；
私人：
类节点
{
友元类迭代器；
朋友类链接列表；
char*m_单词；
Node*m_next；
节点（const char*word，Node*next=NULL，Node*prev=NULL）；
~Node（）；
};
节点*m_头，*m_尾；
大小(m)个;；
公众：
LinkedList（）：m_head（NULL），m_tail（NULL），m_num（0）{}；
~LinkedList（）；
LinkedList和addFirst（常量字符*单词）；
LinkedList和addLast（常量字符*单词）；
迭代器擦除（迭代器&it）；
迭代器begin（）；
迭代器end（）；
迭代器查找（常量字符*单词）；
size_t size（）常量{return m_num；}；
作废打印（）；
友元类迭代器；
类迭代器
{
LinkedList&m_列表；
节点*m_prev，*m_cur；
朋友类链接列表；
下一步无效（）；
void setLast（）{m_cur=NULL，m_prev=m_list.m_tail；}
公众：
迭代器（LinkedList&LinkedList）：m_列表（LinkedList），m_prev（NULL），m_cur（LinkedList.m_head）{}
迭代器和运算符++（）；
字符*运算符*（）；
布尔运算符！=（迭代器&it）{return（mucur！=it.mucur | | mu prev！=it.mu 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;
//}

#包括“LinkedList.h”
LinkedList:：Node:：Node（常量字符*word，LinkedList:：Node*prev，LinkedList:：Node*next）
{
char*tmpWord=新字符[strlen（单词）+1]；
strcpy（tmpWord，word）；
m_word=tmpWord；
m_next=next；
如果（上一个！=NULL）
prev->m_next=这个；
}
LinkedList:：Node:：~Node（）
{
删除[]个单词；
}
LinkedList:：~LinkedList（无效）
{
for（迭代器it=begin（）；it！=end（）；）
抹去（它）；
}
LinkedList&LinkedList:：addFirst（常量字符*word）
{
节点*节点=新节点（字，空，m_头）；
m_头=节点；
如果（m_tail==NULL）
m_尾=m_头；
++m_num；
归还*这个；
}
LinkedList&LinkedList:：addLast（常量字符*word）
{
如果（m_head==NULL）
addFirst（单词）；
其他的
{
Node*Node=新节点（word，m_tail，NULL）；
m_tail=节点；
}
++m_num；
归还*这个；
}
LinkedList:：迭代器LinkedList:：begin（）
{
迭代器it（*this）；
归还它；
}
LinkedList:：迭代器LinkedList:：end（）
{
迭代器it（*this）；
it.setLast（）；
归还它；
}
LinkedList:：Iterator LinkedList:：erase（LinkedList:：Iterator&it）
{
如果（it.m_cur！=NULL）
{
节点*tmp=it.m\u cur；
如果（it.m_prev！=NULL）
it.m_cur=it.m_prev->m_next=tmp->m_next；
其他的
it.m_cur=it.m_list.m_head=tmp->m_next；
if（tmp==it.m_list.m_tail）
it.m_list.m_tail=NULL；
删除tmp；
--m_num；
}
归还它；
}
LinkedList:：迭代器LinkedList:：查找（const char*word）
{
迭代器it=begin（）；
for（；it！=end（）；++it）
{
如果（！strcmp（it.m\u cur->m\u word，word））
打破
}
归还它；
}
void LinkedList:：Iterator:：next（）
{
如果（m_cur！=NULL）
{
m_prev=m_cur；
m_cur=m_cur->m_next；
}
其他的
m_prev=NULL；
返回；
}
作废链接列表：：打印（）
{
for（迭代器it=begin（）；it！=end（）；++it）
不能用词；
}
LinkedList:：Iterator&LinkedList:：Iterator:：operator++（）
{
next（）；
归还*这个；
}
char*LinkedList:：迭代器:：运算符*（）
{
返回mucur->muword；
}
//int main（）
//{
//链接列表ll；
//ll.addFirst（“1”）；
//ll.addFirst（“2”）；
//ll.addLast（“3”）；
//ll.addLast（“4”）；
//LinkedList:：Iterator it=ll.find（“5”）；
//返回0；
//}

如果

new

失败，那么您不必担心内存泄漏，因为您还没有分配任何内容。如果需要，您可以记录该错误消息，然后继续使用现有的链表。

我在那里没有看到任何异常处理程序。iammilind的回答是公平的，但即使您不想记录失败，您也必须编写一个异常处理程序，因为如果您不这样做，异常将上升到更高的上下文，它可以通过一条众所周知的消息停止您的程序，您可以在调试器中看到这条消息：UNHANDLED EXTEPTION at。。。。 我怀疑你是在“内存泄漏”这个词下说的

“新节点”失败后，将引发异常

因此，我必须在异常处理程序中显式调用析构函数

否。如果构造函数未完成，则无法调用析构函数（对象从未创建）

如何处理这种情况以防止内存泄漏

如果在new（std：：bad_alloc）中抛出异常，则无需执行任何操作

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

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

但是您的类中有一个原始指针。你还没有读过3法则（查一查）。目前，由于您不遵守规则3，以下代码将崩溃

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

    LinkedList    list2(list1);
}

---

你又把你的问题贴出来了？我想为什么我的答案没有出现！：）请不要问同一个问题两次-这会分散人们思考答案的注意力。如果你想存储字符串，