我应该如何在C＆＃x2b;＆＃x2B;中为此类编写destructor？

Question

我有一个具有这种结构的课程：

class myClass(){
  public:
    myClass(){//empty constructor}
    
    void insertRecursively(string word) {
        myClass* node = this;
        for (int i = 0; i < word.length(); i++) {
            if (node->map.find(word.at(i)) == node->map.end()) {
                node->map[word.at(i)] = new myClass();
            }
            node = node->map[word.at(i)];
        }
        node->isEnd = true;
    }

  
  private:
    unordered_map<char, myClass*> map = {};
    bool isEnd = false;
}

我尝试以这种方式编写destructor，但它给我错误的“ std :: bad_alloc'：

~myClass() {
    clear(map);
}

void clear(unordered_map<char, myClass*> map) {
    for (auto& pair : map) {
        if (pair.second != nullptr) {
            clear(pair.second->map);
        }
        delete pair.second;
    }
}

从我到目前为止所知道的，我使用新关键字在堆上分配了内存，所以我应该应该为myclass创建驱动器。我需要递归地这样做，因为地图包含其他myllass指针的指针。

我已经研究了几个小时，但仍然无法弄清楚。 谁能帮助我发现会导致“ std :: bad_alloc”的问题？

我的整个代码：

class Trie {
public:
    Trie() {
    }

    void insert(string word) {
        Trie* node = this;
        for (int i = 0; i < word.length(); i++) {
            if (node->map.find(word.at(i)) == node->map.end()) {
                node->map[word.at(i)] = new Trie();
            }
            node = node->map[word.at(i)];
        }
        node->isEnd = true;
    }

    bool search(string word) {
        Trie* node = this;
        for (int i = 0; i < word.length(); i++) {
            if (node->map.find(word.at(i)) == node->map.end()) {
                return false;
            } else {
                node = node->map[word.at(i)];
            }
        }
        return node->isEnd;
    }

    bool startsWith(string prefix) {
        Trie* node = this;
        for (int i = 0; i < prefix.length(); i++) {
            if (node->map.find(prefix.at(i)) == node->map.end()) {
                return false;
            } else {
                node = node->map[prefix.at(i)];
            }
        }
        return true;
    }

    ~Trie() {
        clear(map);
    }

    void clear(unordered_map<char, Trie*> map) {
        for (auto& pair : map) {
            if (pair.second != nullptr) {
                clear(pair.second->map);
            }
            delete pair.second;
        }
    }

private:
    unordered_map<char, Trie*> map = {};
    bool isEnd = false;
};

Answer 1

我将注意力集中在以下代码上。

unordered_map<char, myClass*> map = {};
void clear(unordered_map<char, myClass> map)

修剪几个字符...

unordered_map<char, myClass*> map
void clear(unordered_map<char, myClass> map)

观察到您在char和myclass*上声明了本地项目地图，但是您将clear（）宣布为在char和myclass上的地图上操作，而不是通过char和myclass*的地图。

*有所作为。

Answer 2

您要么开始使用 Smart Pointer ，要么需要提出一个用myClass实例创建的new的概念。

后者可能是：

• Instances myClass的A由myClass的另一个实例所有（让我们称其为ander> lands）其中＆amp; a出现在所有者.map中（您已经在执行此操作）。
• 每当实例所有者被销毁时，它必须（直接）释放所有实例：

~myClass() {
  for(const auto& pair : map){
    delete pair.second;
  }
}

Answer 3

您的trie :: clear（）方法两次删除相同的trie。

~Trie() {
    clear(map);
}

void clear(unordered_map<char, Trie*> map) {
    for (auto& pair : map) {
        if (pair.second != nullptr) {
            clear(pair.second->map);
        }
        delete pair.second;
    }
}

destructor 〜trie调用clear（pair.second-＆gt; map），然后调用delete pair.second.second，与clear（pair.second-＆gt; map）由于delete调用指向at数据的删除器。在同一地图上两次呼叫clear（）两次意味着第二个调用试图删除已删除的数据，这会导致崩溃。调用delete在指针上不会更改指针的值，这就是为什么nullptr检查检查什么都不做。

由于destructor调用clear（），因此clear（）方法无需清楚地递归地调用自己。只需删除地图指针即可。

~Trie() {
    clear(map);
}

void clear(unordered_map<char, Trie*> map) {
    for (auto& pair : map) {
        delete pair.second;
    }
}

顺便说一句，调用删除NullPtr是可以的，因为它不需要任何事情。