These are the files:
//============================================================================
// Name : linearMatrix.hpp
// Author : Flores, Facundo Gabriel
// Version : 0.1
// Description : This file contains the linearMatrix class.
//===========================================================================
#ifndef LINEARMATRIX_HPP_
#define LINEARMATRIX_HPP_
class linearMatrix
{
public:
//Constructor
linearMatrix(const int Width, const int Heigth);
//Destructor
~linearMatrix();
//We read a matrix file
void Read_File_Matrix(const char *Path);
//We write a matrix file
void Write_File_Matrix(const char *Path);
//Generate a diagonal dominant matrix
void Generate_Diagonal_Dominant(void);
//Generate a random matrix
void Generate_Random_Matrix(void);
//Copy a float *vector
void Copy_Vector(const float *V, const int Width, const int Heigth);
//Show a little vector
void Show_Little_Matrix(void);
private:
int _Width, _Height; // Width and Height
float* myVector;
//Aux function for testing
bool Test_Sizes(const int Width, const int Heigth);
};
#endif /* LINEARMATRIX_HPP_ */
//============================================================================
// Name : linearMatrix.cpp
// Author : Flores, Facundo Gabriel
// Version : 0.1
// Description : This file contains the linearMatrix implementation class.
// A linear matrix is a vector that represents a matrix.
// We will read this kind of classes from files, because
// they are generally large. But linearMatrix can represent
// a 1D vector if Height is 1.
//============================================================================
#include <iostream>
using std::cout;
using std::endl;
using std::cerr;
using std::bad_alloc;
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <new>
#include "linearMatrix.hpp"
#define FALSE 0
#define TRUE 1
//Test if W and H are correct
bool linearMatrix::Test_Sizes(const int W, const int H)
{
if(W < 1 || W > 32500)
return FALSE;
if(H < 1 || H> 32500)
return FALSE;
return TRUE;
}
// We set the Width and Height parameters
linearMatrix::linearMatrix(const int Width, const int Height)
{
if(Test_Sizes(Width, Height))
{
_Width = Width;
_Height = Height;
try{
myVector = new float[_Width * _Height];
}
catch(bad_alloc &ex)
{
cerr << "Exception:" << ex.what();
exit(1);
}
}
else
{
cout<<"Bad sizes!"<<endl;
exit(1);
}
}
linearMatrix::~linearMatrix()
{
delete [] myVector;
}
//We set a random vector using its Width and Height
void linearMatrix::Generate_Random_Matrix(void)
{
srand(time(NULL));
for(int i = 0; i < _Width; i++)
for(int j = 0; j < _Height; j++)
{
// We are putting a number between 0 and 99
myVector[i * _Width + _Height] = rand() % 100;
}
}
//We set a diagonal dominant matrix
void linearMatrix::Generate_Diagonal_Dominant(void)
{
for(int i = 0; i < _Width; i++)
for(int j = 0; j < _Height; j++)
{
if(i == j) //Diagonal item
myVector[i * _Width + j] = 32500;
else
myVector[i * _Width + j] = 0.5;
}
}
//We copy V into myVector
void linearMatrix::Copy_Vector(const float *V, const int Width, const int Heigth)
{
if(Width != _Width || Heigth != _Height)
{
cout<<"Different sizes, we cannot copy vector V"<<endl;
exit(1);
}
else
{
for(int i = 0; i < _Width; i++)
for(int j = 0; j < _Height; j++)
{
myVector[i * _Width + j] = V[i * Width + j];
}
}
}
//We show a little matrix. Assume H < 11 and W < 11
void linearMatrix::Show_Little_Matrix(void)
{
cout.precision(5);
if(_Height < 11 && _Width < 11)
{
for(int i = 0; i < _Width; i++)
{
for(int j = 0; j < _Height; j++)
{
cout<<myVector[i * _Width + j]<<" ";
}
cout << endl;
}
}
else
{
cout << "I can show only little matrices in the console " << endl;
}
}
void linearMatrix::Write_File_Matrix(const char *Path)
{
FILE *pFile = fopen(Path, "wb");
fwrite(&_Height, sizeof(int), 1, pFile);
fwrite(&_Width, sizeof(int), 1, pFile);
fwrite(myVector, sizeof(float), _Height * _Width, pFile);
fclose(pFile);
}
void linearMatrix::Read_File_Matrix(const char *Path)
{
FILE *pFile = fopen(Path, "rb");
if(pFile == NULL){
cout << "Cannot read :" << Path << endl;
exit(1);
}
fread(&_Height, sizeof(int), 1, pFile);
fread(&_Width, sizeof(int), 1, pFile);
try{
myVector = new float[_Width * _Height];
}
catch(bad_alloc &ex)
{
cout << "Exception:" << ex.what();
exit(1);
}
fread(myVector, sizeof(double), _Height * _Width, pFile);
}
And I'm trying to use this class with the following main.cpp:
//============================================================================
// Name : main.cpp
// Author : Flores, Facundo Gabriel
// Version : 0.1
// Description : This file is a test.
//===========================================================================
#include <iostream>
#include "linearMatrix.hpp"
int main(void)
{
linearMatrix Matrix2(3,1);
Matrix2.Generate_Diagonal_Dominant();
Matrix2.Show_Little_Matrix();
return 0;
}
So the error is:
*** glibc detected *** /.../linearMatrix/Debug/linearMatrix: free(): invalid next size (fast): 0x00000000007f1010 ***
I don't know how to use valgrind yet. But why is the error there? The program shows me the correct output, but when the destructor is "executed" the error appears while freeing myVector. How to solve it?
