Ошибка при освобождении памяти

Это файлы:

//============================================================================
// 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);
}

И я пытаюсь использовать этот класс со следующими 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;
}

Итак, ошибка:

*** glibc detected *** /.../linearMatrix/Debug/linearMatrix: free(): invalid next size (fast): 0x00000000007f1010 ***

Я не знаю как пользоваться valgrind еще. Но почему ошибка там? Программа показывает мне правильный вывод, но когда деструктор «выполняется», появляется ошибка при освобождении myVector, Как это решить?