c++ - 我的代码出现内存泄漏问题，我是新手

Question

我一直在发生内存泄漏，这似乎是因为作为add(…)的指针传递的新的初始化对象实际上不是delete。但是以某种方式，我无法使其正常工作。我尝试添加for -loop以在调用delete的调用时循环将Monsters类中数组中的每个对象循环化为destructor每个对象。然后做delete[] monsters;和monsters = nullptr。
https://repl.it/@xxxxxx10/TatteredTroubledTasks

#include <iostream>
#include <string>

class Monster{
public:
  Monster(){};
  Monster(std::string name) : name(name){}
private:
  std::string name = "";
};

class MonstersList {
public:
  MonstersList(int max):max(max){
    monsters = new Monster[max];
  }
  
  virtual ~MonstersList() {
      delete[] monsters;
  }

  void add(const Monster* m){
    monsters[total++] = *m;
  }

 Monster* begin() const { return monsters; }
 Monster* end() const { return monsters + total; }

private:
  Monster* monsters = nullptr;
  int max = 0;
  int total = 0;
};

MonstersList* InitListOfMonsters()
{
    MonstersList* monsters = new MonstersList(2);
    monsters->add(new Monster("Sally"));
    monsters->add(new Monster("Rich"));
    
    return monsters;
}

int main()
{
  MonstersList* monsters = InitListOfMonsters();
  
  // Do something here...

  return 0;
} // <----- Memory leak!

如何防止这种情况发生，回想起来，我试图进行循环并删除数组中的每个怪物指针对象。
编辑:当我尝试for循环删除每个对象时，会发生一种错误，在 delete_scalar.cpp <-Microsoft C++文件处中断。

_CRT_SECURITYCRITICAL_ATTRIBUTE
void __CRTDECL operator delete(void* const block) noexcept
{
    #ifdef _DEBUG
    _free_dbg(block, _UNKNOWN_BLOCK);
    #else
    free(block);
    #endif
}

当我在 destructor中运行此代码时发生:

if (monsters != nullptr) {
    for (Monster* m = begin(); m != end(); m++) {
        delete m;
    }

    delete[] monsters;
    monsters = nullptr;
}

Answer 1

好吧，这是我上学的努力。在代码的各个位置查看注释，以了解丢失的内容。
引用文献
What is The Rule of Three?
What is the copy-and-swap idiom?
知道这些东西是件好事，尽管这并不意味着您应该是守旧派。现代C++更好。

#include <iostream>
#include <algorithm>
#include <string>

class Monster
{
public:
    Monster() {};
    Monster(std::string name) : name(name) {}
private:
    std::string name = "";
};

class MonstersList
{
public:
    MonstersList(int max) : monsters(new Monster[max]), max(max), total(0)
    {
    }

    // copy constructor, essential if your destructor deletes, see rule of three
    MonstersList(const MonstersList& rhs) : monsters(new Monster[rhs.max]), max(rhs.max), total(rhs.total)
    {
        std::copy(rhs.begin(), rhs.end(), begin());
    }

    // assignment operator, again essential with a deleting destructor, 
    // this implementation uses the copy and swap idiom
    MonstersList& operator=(MonstersList rhs)
    {
        swap(rhs);
        return *this;
    }

    virtual ~MonstersList()
    {
        delete[] monsters;
    }

    void swap(MonstersList& rhs)
    {
        std::swap(monsters, rhs.monsters);
        std::swap(max, rhs.max);
        std::swap(total, rhs.total);
    }

    void add(const Monster& m) // pass by reference
    {
        monsters[total++] = m;
    }

    Monster* begin() const { return monsters; }
    Monster* end() const { return monsters + total; }

private:
    Monster* monsters;
    int max;
    int total;
};

MonstersList* InitListOfMonsters()
{
    // allocate a list of monsters, but no need to allocate the monsters themselves
    MonstersList* monsters = new MonstersList(2);
    monsters->add(Monster("Sally"));
    monsters->add(Monster("Rich"));

    return monsters;
}

int main()
{
    MonstersList* monsters = InitListOfMonsters();
    // Do something here...

    // don't forget to delete the monster list
    delete monsters;
    return 0;
}