Qual è il problema con questo codice?Perché non mostrare:Debug asserzione non riuscita!_BLOCK_TYPE_IS_VALID(pHead->nBlockUse)?

Question

Cosa c'è di sbagliato nel codice?

Cosa cambia se faccio il codice per renderlo difensiva?

Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_

class Array
{
private:
    int * m_ArrayContainer;

public:
    Array();
    void AllocateMemoryOfSize(int size);
    void DeallocateMemory();
    void SetElementsIntoTheIndex(int index, int value);
    int GetElementFromIndex(int index);
    int operator [] (int index);
    ~Array();
};

#endif

Array.cpp

#include "Array.h"
#include <iostream>

Array :: Array()
{
    this->m_ArrayContainer = NULL;
}

void Array :: AllocateMemoryOfSize(int size)
{
    this->m_ArrayContainer = new int[size];
}

void Array :: DeallocateMemory()
{
    delete [] this->m_ArrayContainer;
}

void Array :: SetElementsIntoTheIndex(int index, int value)
{
    this->m_ArrayContainer[index] = value;
}

int Array :: GetElementFromIndex(int index)
{
    return this->m_ArrayContainer[index];
}

int Array :: operator [] (int index)
{
    return this->m_ArrayContainer[index];
}

Array :: ~Array()
{
    this->DeallocateMemory();
}

Main.cpp

#include <iostream>
#include "Array.h"

int main()
{   
for(int i=0 ; i<250 ; i++)
{
    Array array1;
    array1.AllocateMemoryOfSize(3);
    array1.SetElementsIntoTheIndex(0, 10);
    array1.SetElementsIntoTheIndex(1, 10);
    array1.SetElementsIntoTheIndex(2, 10);

    /*array1.SetElementsIntoTheIndex(0, NULL);
    array1.SetElementsIntoTheIndex(1, NULL);
    array1.SetElementsIntoTheIndex(2, NULL);*/

    array1.DeallocateMemory();
}
}

Answer 1

Il distruttore chiama DeallocateMemory() per la seconda volta e che porta a delete[] di essere chiamato per la seconda volta con lo stesso indirizzo in cui si innesca un comportamento indefinito.Per guarg contro questo si dovrebbe cambiare

void Array::DeallocateMemory()
{
    delete [] this->m_ArrayContainer;
    this->m_ArrayContainer = 0;
}

in modo che quando viene chiamato il distruttore e chiamate DeallocateMemory() un puntatore è null delete[]d, che è un no-op.

Btw si dovrebbe almeno vietare costruttore di copia e operator= nella tua classe, dichiarando il loro privato e lasciando implementate - la classe non supporta memberwise copia.

Answer 2

Perché in ogni iterazione del ciclo chiami delete[] due volte sullo stesso array assegnato. Una volta tramite una chiamata esplicita a DeallocateMemory e una volta tramite la chiamata nel distruttore di Array.