Question

它在main（）函数的最后崩溃，它需要删除启动器对象。运行程序时弹出的错误消息说：调试断言失败！表达式：_BLOCK_IS_VALID（pHead-> nBlockUse）。如何修复它在删除启动器对象时崩溃？

#include <iostream>
#include <fstream>
#include "olympic.h"

using namespace std;

ofstream csis;

int main() {
const int lanes = 4;
Ranker rank(lanes);

csis.open("csis.txt");

// First make a list of names and lane assignments.
Competitor* starters[lanes];

starters[0] = new Competitor("EmmyLou Harris", 1);
starters[1] = new Competitor("Nanci Griffith", 2);
starters[2] = new Competitor("Bonnie Raitt", 3);
starters[3] = new Competitor("Joni Mitchell", 4);

// The race is run; now assign a time to each person.
starters[0]->setTime((float)12.0);
starters[1]->setTime((float)12.8);
starters[2]->setTime((float)11.0);
starters[3]->setTime((float)10.3);

// Put everyone into the ranker.
for (int i = 0; i < lanes; i++)
    rank.addList(starters[i]);

// Now print out the list to make sure its right.
cout << "Competitors by lane are:" << endl;
csis << "Competitors by lane are:" << endl;
for (int i = 1; i <= lanes; i++)
    rank.getLane(i)->print();

// Finally, show how they finished.
cout << "Rankings by finish are:" << endl;
csis << "Rankings by finish are:" << endl;
for (int i = 1; i <= lanes; i++)
    rank.getFinish(i)->print();
for (int i = 0; i < lanes; i++)
    delete starters[i];

csis.close();

}

ranker.cpp：

#include "ranker.h"
#include "competitor.h"
#include <stdlib.h>

Ranker::Ranker(int lanes) {
athlete = new Competitor*[lanes]; 
numAthletes = 0;
maxAthletes = lanes;
}

int Ranker::addList(Competitor* starter) {
if (numAthletes < maxAthletes && starter != NULL) {
    athlete[numAthletes] = starter;
    numAthletes++;

    return numAthletes;
}
else
    return 0;
}

Competitor* Ranker::getLane(int lane) {
for (int i = 0; i < numAthletes; i++) {
    if (athlete[i]->getLane() == lane) {
        return athlete[i];
    }
}
return NULL;
}


Competitor* Ranker::getFinish(int position) {
switch(position) {
    case 1:
        return athlete[3];
        break;
    case 2:
        return athlete[2];
        break;
    case 3:
        return athlete[1];
        break;
    case 4:
        return athlete[0];
        break;
}
return NULL;
}

int Ranker::getFilled() {
return numAthletes;
}

Ranker::~Ranker() {
delete [] athlete;
}

competitor.h：

#ifndef _COMPETITOR_H
#define _COMPETITOR_H

 class Competitor {
     private:
        char* name;
        int lane;
        double time;
     public:
        Competitor(char* inputName, int inputLane);
        Competitor();
        void setTime(double inputTime);
        char* getName();
        int Competitor::getLane();
        double getTime();
        void print();
       ~Competitor();
    };

    #endif

competitor.cpp：

#include "competitor.h"
#include <string>
#include <iostream>
#include <iomanip>

using namespace std;


 Competitor::Competitor(char* inputName, int inputLane) {
name = inputName;
lane = inputLane;
}

Competitor::Competitor() {
name = 0;
lane = 0;
time = 0;
}

 void Competitor::setTime(double inputTime) {
time = inputTime;
}

char* Competitor::getName() {
return name;
}

int Competitor::getLane() {
return lane;
 }

 double Competitor::getTime() {
return time;
}

void Competitor::print() {
cout << setw(20) << name << setw(20) << lane << setw(20) << setprecision(4) << time        << endl;
}

Competitor::~Competitor() {
delete [] name;
}

调用堆栈：

崩溃前的

：http://i.imgur.com/d4sKbKV.png 崩溃后：http://i.imgur.com/C5cXth9.png

Answer 1

在您添加竞争对手类后，似乎问题是您在竞争对手的析构函数中删除了其名称。但是你从字符串文字中分配它，它实际上无法删除。我确信导致断言的堆栈跟踪将证明这一点。

解决问题的一种方法是使用std :: string来存储名称。

Answer 2

问题是在析构函数上删除char *值时，使用const char而不是new char赋值。所以我稍微改变了构造函数，将const char复制到新的char。

Competitor::Competitor(char* inputName, int charlen, int inputLane) 
{
name = new char[charlen + 1];
memcpy(name , inputName, charlen );
name [charlen] = '\0'; 
lane = inputLane;
}

删除对象时崩溃

2 个答案: