Warum kann ich meinen dynamisch zugewiesenen Speicher nicht mit dem Schlüsselwort "delete" zurückfordern?

Question

Ich habe die folgende Klasse:

class Patient { 
public: 
    Patient(int x); 
    ~Patient(); 
private: 
    int* RP; 
}; 

Patient::Patient(int x) { RP = new int [x]; } 
Patient::~Patient() { delete [] RP; } 

ich eine Instanz dieser Klasse auf dem Stapel wie folgt erstellen:

void f() { Patient p(10); } 

Nun, wenn f() zurückkehrt, ich eine „doppelte frei oder Korruption“ erhalten Fehler, der mir signalisiert, dass versucht wird, etwas mehr als einmal zu löschen. Aber ich verstehe nicht, warum das so wäre. Der Platz für das Array wird auf dem Heap erstellt, und nur weil die Funktion, in der der Space zugewiesen wurde, zurückkehrt, würde ich nicht erwarten, dass der Space zurückgewonnen wird.

Ich dachte, dass, wenn ich Speicherplatz auf dem Heap zuweisen (mit dem Schlüsselwort new), dann die einzige Möglichkeit, diesen Speicherplatz zurückzugewinnen ist, verwenden Sie das Schlüsselwort löschen. Hilfe!

Wie gewünscht, hier ist der eigentliche Code (etwas der Kürze halber gekürzt)

Hier ist die vollständige Klassendefinition (split über eine .cpp und .h Datei, aber zusammen dargestellt):

class Patient { 

public: 
    Patient(int numDecisionEpochs); 

    ~Patient(); 

    void recordRP(const int& age, const bool& t); 
    void recordBiopsy(const int& age, const int& result); 
    void recordPSA(const int& age, const double& level); 
    void recordPSA(const int& age); 
private: 
    int* RP; 
    int* Biopsy; 
    double* PSA; 
}; 

Patient::Patient(int numDecisionEpochs) { 
    RP = new int [numDecisionEpochs]; 
    Biopsy = new int [numDecisionEpochs]; 
    PSA = new double [numDecisionEpochs]; 
} 

Patient::~Patient() { 
    delete[] RP; 
} 

void Patient::recordRP(const int& age, const bool& t) { 
    if(t) 
    RP[age-1] = 1; // RP either yes (1) or no (0) 
    else 
    RP[age-1] = 0; 
} 

void Patient::recordBiopsy(const int& age, const int& result) { 
    switch(result) 
    { 
    case 0: 
    case 1: 
    case 2: 
    case 3: 
    case 4: 
     Biopsy[age-1]=result; // only permit results 0,1,2,3,4 
     break; 
    default: 
     cerr << "Invalid biopsy result (" << result << ") at age " << age << "!\n"; 
    } 
} 

void Patient::recordPSA(const int& age, const double& level) { 
    PSA[age-1] = level; // record PSA volume 
} 

void Patient::recordPSA(const int& age) { 
    PSA[age-1] = -1; // symbol for no screening during epoch 
} 

Als nächstes die Funktion, wo die obige Klasse verwendet wird. Die folgende Funktion wird direkt von main() genannt und verabschiedete ein Policy Objekt, das völlig unabhängig und getrennt von der Patient Klasse:

void simulate1(Policy& P) 
{ 
    // ... 
    Patient patient(260); 

    for(int idx=0; idx<(P.size); idx++) 
    { 
     while(state != 9) // while patient not dead 
     { 
       // ... 
       patient.recordPSA(age,PSA); 
       // ... 
       patient.recordPSA(age); 
       // ... 
       patient.recordBiopsy(age,biopsyResult); 
       // ... 
       patient.recordRP(age,true); 
       // ... 
       patient.recordRP(age,false); 
       // ... 

     } // end patient (while loop) 

    } // end sample (for loop) 

} // end function 

Answer 1

Sie verletzen die rule-of-three (oder für C++ 11, die rule-of-five). Sie benötigen einen Kopierkonstruktor und einen Kopierzuweisungsoperator, der eine tiefe Kopie des Zeigers ausführt. Da Sie die Größe des zugewiesenen Arrays nicht verfolgen, ist dies natürlich ohne die Einführung eines zweiten Datenelements nicht möglich.

Answer 2

Dies beantwortet Ihre Frage nicht direkt, sondern auch die Verwendung von std :: vector.

Answer 3

Es gibt nichts in den record... Methoden, die Grenzen das Alter überprüft. Wenn also das Alter in Ihrem Beispiel größer als 260 oder kleiner als 0 ist, schreiben Sie über die Grenzen von RP oder Biopsy oder PSA. Das führt direkt zu einem "doppelten freien oder Korruption" -Fehler.