删除对象时发生崩溃

Question

它在main（）函数的最后碰撞时需要删除starters对象。运行程序时弹出的错误消息说：调试断言失败！表达式：_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 *值，该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; 
}