在C ++中使用动态数组指针时内存泄漏

Question

正如标题所示，我运行程序时会出现内存泄漏。但是，我认为问题是我没有告诉析构函数在程序完成时释放所有内存。但问题是当我尝试将我的freeMemory（）函数放入析构函数时，程序崩溃了。编译器说我的基类中的函数getString（）无法从字符串中读取。我想知道你是否能看到这个问题，因为我肯定不能......而且为了不获得太多的代码行，我只会发布可能是泄漏源的函数。 handler.h中：

class Handler {
private:
    Competitor* *person;
    int capacity;
    int nrOfCompetitors;
    void expand();
    void initiate(int start) const;
    int find(string name) const;
    void freeMemory();
public:
    Handler(int capacity = 3);
    Handler(const Handler & origObj);
    virtual ~Handler();
    Handler operator=(const Handler & origObj);
    bool addExerciser(string name, string gender, int age);
    bool addProffs(string name, string gender, string compound, int nrOfSeasons);
    void getCompetitors(string arr[]) const;
    int getNrOfCompetitors() const;
    void getProffs(string arr[]) const;
    int getNrOfProffs() const;
    void getExercisers(string arr[]) const;
    int getNrOfExercisers() const;
    bool removeCompetitor(string name);
    bool changeNrOfSeasons(string name, int newNrOfSeasons) const;
    void sortCompetitors();
};

Handler.cpp（只是相关功能）：

void Handler::expand() {
    this->capacity += 5;
    Competitor* *tmp = new Competitor*[capacity];

    for (int i = 0; i < this->nrOfCompetitors; i++) {
        tmp[i] = this->person[i];
    }
    delete[] this->person;

    this->person = tmp;
    this->initiate(nrOfCompetitors);
}

void Handler::initiate(int start) const {
    for (int i = start; i < this->capacity; i++) {
        person[i] = nullptr;
    }
}

void Handler::freeMemory() {
    for (int i = 0; i < nrOfCompetitors; i++) {
        delete person[i];
    }
    delete[] person;
}

Handler::Handler(int capacity) {
    this->capacity = capacity;
    this->nrOfCompetitors = 0;
    this->person = new Competitor*[this->capacity];
    initiate(0);
}

Handler::Handler(const Handler & origObj) {
    this->capacity = origObj.capacity;
    this->nrOfCompetitors = origObj.nrOfCompetitors;
    this->person = new Competitor*[origObj.capacity];
    for (int i = 0; i < this->capacity; i++) {
        person[i] = origObj.person[i];
    }
    initiate(nrOfCompetitors);
}

Handler::~Handler() {
    //freeMemory();
    delete[] person;
}

Handler Handler::operator=(const Handler & origObj) {
    if (this != &origObj) {
        freeMemory();
        this->capacity = origObj.capacity;
        this->nrOfCompetitors = origObj.nrOfCompetitors;
        this->person = new Competitor*[origObj.capacity];
        for (int i = 0; i < this->capacity; i++) {
            person[i] = origObj.person[i];
        }
        initiate(nrOfCompetitors);
    }
    return *this;
}

bool Handler::removeCompetitor(string name) {
    bool removed = false;
    int found = find(name);

    if (found != -1) {
        delete person[found];
        for (int i = found; i < nrOfCompetitors; i++) {
            person[found] = person[found + 1];
        }
        delete person[nrOfCompetitors];
        nrOfCompetitors -= 1;
        removed = true;
    }

    return removed;
}

void Handler::sortCompetitors() {
    Competitor* tmp;
    bool swap;

    do {
        swap = false;
        for (int i = 0; i < nrOfCompetitors - 1; i++) {
            if (person[i]->getName() > person[i + 1]->getName()) {
                tmp = person[i];
                person[i] = person[i + 1];
                person[i + 1] = tmp;
                swap = true;
            }
        }
    } while (swap);
}

编辑： 当我尝试在析构函数中使用freeMemory（）函数时程序崩溃，编译器说我的基类中的getString（）函数无法从字符串中读取字符。

Competitor.h（基类）：

string getString() const;
virtual string getSpecificString() const = 0;

Competitor.cpp：

string Deltagare::getString() const {
    return "Name: " + this->name + "\nGender: " + this->gender + "\n" + this->getSpecificString();
}

Exerciser.h（子类）：

virtual string getSpecificString() const;

Exerciser.cpp

string Exerciser::getSpecificString() const {
    return "Age: " + to_string(this->age);
}

解决！解： 问题出在析构函数，赋值运算符和复制构造函数中，但它们现在已得到修复。我使用克隆方法，因为我无法输入person [i] = new Competitor [origObj.person [i]]，因为竞争者类是抽象类。

Competitor.h：

virtual Competitor* clone() const = 0;

Exerciser.h：

Exerciser* clone() const;

Exerciser.cpp：

Exerciser * Exerciser::clone() const {
    return new Exerciser(*this);
}

在复制构造函数和赋值运算符中进行编辑：

this->person = new Competitor*[origObj.capacity];
    for (int i = 0; i < origObj.nrOfCompetitors; i++) {
        person[i] = origObj.person[i]->clone();
    }

在析构函数中编辑：

Handler::~Handler() {
    freeMemory();
}