Question

I gave this a class Histogram and i am dynamically allocating memory for my class. I have issues with the destructor. The error is:

Expression:_BLOCK_TYPE_IS_VALID_(pHead->pBlockUse)

What i am doing wrong?

histogram.h

 #ifndef HISTOGRAM_H
    #define HISTOGRAM_H
    #include<iostream>
    class Histogram
    {
    private:
        int** matrix;
        int lines;  
        double* normalizedArray;
        int *values;
        void SortMatrix();      
    public:
        Histogram(int elements[], int elementsNr);
        Histogram(int** matrix, int lines);
        void Normalize();
        void PrintNormalized();
        void PrintDenormalized();
        void PrintValues();
        void PrintNormalizedArray();
        int* GetValues() const {return values;} 
        double* GetNormalizedArray() const {return normalizedArray;}
        int GetLines() const {return lines;}
        double CalculateD1(Histogram histo);
        double CalculateD2(Histogram histo);
        double CalculateIntersection(Histogram hist);
        ~Histogram(){
        delete []matrix;
        delete []normalizedArray;
        delete []values;
        }
    };
    #endif
histogram.cpp

     #include<math.h>
#include"histogram.h"
using namespace std;
Histogram::Histogram(int** m, int l)
{
    lines=l;
    normalizedArray=NULL;
    values=NULL;
    matrix=new int*[lines];
    for(int i=0;i<lines;i++)
    {
        matrix[i]=new int[2];
    }
    for(int i=0;i<lines;i++)
    {
        matrix[i][0]=m[i][0];
        matrix[i][1]=m[i][1];
    }

    SortMatrix();
    //save the values
    values=new int[lines];
    for(int i=0;i<lines;i++)
    {
        values[i]=matrix[i][0];
    }
}

Histogram::Histogram(int elements[], int elementsNr)
{
    lines=0;
    normalizedArray=NULL;
    //initialize matrix : elementrNr lines and 2 columns
    matrix=new int*[elementsNr];
    for(int i=0;i<elementsNr;i++)
    {
        matrix[i]=new int[2];
        matrix[i][0]=INT_MIN;
        matrix[i][1]=INT_MIN;
    }
    //search each element from the array in the matrix
    bool found=false;
    for(int i=0;i<elementsNr;i++)
    {
        found=false;
        for(int j=0;j<elementsNr;j++)
        {
            //the element was found in the matrix ( on the first column )
            if(matrix[j][0] == elements[i])
            {
                matrix[j][1]++;
                found=true;
                break;
            }
        }
        if(!found)
        {
            matrix[lines][0]=elements[i];
            matrix[lines][1]=1;
            lines++;
        }
    }
    SortMatrix();
    //save the values
    values=new int[lines];
    for(int i=0;i<lines;i++)
    {
        values[i]=matrix[i][0];
    }

}
void Histogram::SortMatrix()
{

    for(int i=0;i<lines;i++)
    {
        for(int j=0;j<lines-1;j++)
        {
            if(matrix[j][0]>matrix[j+1][0])
            {
                int temp = matrix[j+1][0];
                matrix[j+1][0] = matrix[j][0];
                matrix[j][0] = temp;
            }
        }
    }
}

void Histogram::PrintDenormalized()
{
    for(int i=0;i<lines;i++)
    {
        cout<<matrix[i][0]<<" : " <<matrix[i][1]<<endl;
    }

}
void Histogram::PrintNormalized()
{
    for(int i=0;i<lines;i++)
    {
        cout<<matrix[i][0]<<" : "<<normalizedArray[i]<<endl;
    }
}

void Histogram::PrintValues()
{
    for(int i=0;i<lines;i++)
    {
        cout<<values[i]<<endl;
    }
}
void Histogram::PrintNormalizedArray()
{
    for(int i=0;i<lines;i++)
    {
        cout<<normalizedArray[i]<<endl;
    }
}

void Histogram::Normalize()
{
    int N=0;
    normalizedArray=new double[lines];
    for(int i=0;i<lines;i++)
    {
        N+=matrix[i][1];
    }
    for(int i=0;i<lines;i++)
    {
        normalizedArray[i]=static_cast<double>(matrix[i][1])/N;
    }
}

double Histogram::CalculateD1(Histogram histo)
{
    //the two histograms must have the same values
    int* values2 = histo.GetValues();
    int lines2 = histo.GetLines();
    if(lines!=lines2)
    {
        return -1;
    }
    for(int i=0;i<lines;i++)
    {
        if(values[i]!=values2[i])
        {
            return -1;
        }
    }

    //if we got this far the two histograms have the same values, so we can calculate the distance
    double* normalizedArray2=histo.GetNormalizedArray();
    double dist=0.0;
    for(int i=0;i<lines;i++)
    {
        dist +=  abs(normalizedArray[i]-normalizedArray2[i]);
    }
    return dist;
}

double Histogram::CalculateD2(Histogram histo)
{
    //the two histograms must have the same values
    int* values2 = histo.GetValues();
    int lines2 = histo.GetLines();
    if(lines!=lines2)
    {
        return -1;
    }
    for(int i=0;i<lines;i++)
    {
        if(values[i]!=values2[i])
        {
            return -1;
        }
    }

    //if we got this far the two histograms have the same values, so we can calculate the distance
    double* normalizedArray2=histo.GetNormalizedArray();
    double dist=0.0;
    for(int i=0;i<lines;i++)
    {
        dist +=  pow(normalizedArray[i]-normalizedArray2[i], 2);
    }
    return sqrt(dist);
}

double Histogram::CalculateIntersection(Histogram histo)
{
    //the two histograms must have the same values
    int* values2 = histo.GetValues();
    int lines2 = histo.GetLines();
    if(lines!=lines2)
    {
        return -1;
    }
    for(int i=0;i<lines;i++)
    {
        if(values[i]!=values2[i])
        {
            return -1;
        }
    }

    //if we got this far the two histograms have the same values, so we can calculate the intersection
    double* normalizedArray2=histo.GetNormalizedArray();
    double v1=0.0;
    double v2=0.0;
    for(int i=0;i<lines;i++)
    {
        v1 += normalizedArray[i] < normalizedArray2[i] ? normalizedArray[i] : normalizedArray2[i];
        v2 += normalizedArray[i];
    }
    return v1/v2;
}

Answer 1

Neither constructor initializes normalizedArray. This means that the call to delete[] normalizedArray in the destructor will be operating on an unitialized pointer. To correct, initialize normalizedArray in each of the constructors to NULL. Calling delete[] (or delete) on a NULL pointer is safe.

As Histogram has dynamically allocated members you need to either prevent copying:

class Histogram
{
    Histogram(const Histogram&);
    Histogram& operator=(const Histogram&);
};

or correctly implement the copy constructor and assignment operator. See What is The Rule of Three?
Instances of Histogram will be copied if any of the following functions are being called:

double CalculateD1(Histogram histo);         // Pass by const reference instead
double CalculateD2(Histogram histo);         // if the functions do not modify
double CalculateIntersection(Histogram hist) // their argument.

If the copy constructor and assignment operator are not implemented for classes that have dynamically allocated memory then two instances of the class will end up pointing to the same dynamically allocated memory after a copy operation. When one of the two instances is destructed it leaves the other instance with dangling pointers (pointers to memory that is no longer valid). Any attempt to use these is undefined behaviour.

---

If this is not an exercise use std::vector<>s instead. It handles dynamically allocated memory for you:

std::vector<std::vector<int>> matrix;
std::vector<double> normalizedArray;
std::vector<int> values;