析构函数内的析构函数？

Question

我正在尝试按对象删除分配的内存，但它是以链表的形式。有人可以建议一种方法吗？

这是我的头文件

class XKey
{   
public:
    XKey();
    virtual ~XKey();

private:
    char *m_name;
    char *m_value;
    XKey *m_next;
};

class XSection
{   
public:
    XSection();
    virtual ~XSection();  

private:    
    char *m_name;
    XKey *m_keys;
    XSection *m_next;
};

class XIniFile
{
public:
    XIniFile();
    virtual ~XIniFile();

private:
    char *m_name;
    XSection *m_sections;
};

这是我的程序文件

XKey::~XKey()
{
    delete(m_name);
    delete(m_value);
    m_next = 0;
}

XSection::~XSection()
{
    XKey k;
    XKey ks;

    k = m_keys;
    while (k){
        ks = k;
        k = k->getNext();
        //////////////<<<--- How can I call a destructor here from XKey?
        delete(m_name);
        m_keys = 0;
        m_next = 0;
    }
}

XIniFile::~XIniFile()
{
    XSection *sec;
    XSection *sp;

    sec = m_sections;
    while (sec) {
        sp = sec;
         //////////////<<<--- How can I call a destructor here from XSection?
        delete(m_name);
        m_sections = 0;
    }    

}

我有一些错别字，但请关注我如何在析构函数中调用析构函数的算法。谢谢！

Answer 1

如果您将 RAII 与 std::string、std::list 和 std::unique_ptr 一起使用， 您不必在析构函数中手动执行某些操作：

#include <list>
#include <string>
#include <memory> // unique_ptr

class XKey
{   
public:
    virtual ~XKey() = default;

private:
    std::string m_name;
    std::string m_value;
};

class XSection
{   
public:
    virtual ~XSection() = default;

private:
    std::string m_name;
    std::list<std::unique_ptr<XKey>> m_keys;
};

class XIniFile
{
public:
    virtual ~XIniFile() = default;

private:
    std::string m_name;
    std::list<std::unique_ptr<XSection>> m_sections;
};

如果这些类不需要是多态的，您可以使用std::list<T> 而不是std::list<std::unique_ptr<T>>。

Answer 2

XSection::~XSection()
{
    XKey* k = m_keys;   // must be a pointer!

    while (k){
        XKey* ks = k;   // must be a pointer!
        k = k->getNext();
        if (ks != nullptr) delete ks;
    }
    delete [] m_name; // allocated with new[]?
}

这是非常c++98，你应该考虑拥抱c++11（智能指针）