Question

这些是文件：

//============================================================================
// 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时出现。怎么解决？

Answer 1

这是一个错误

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;
        }
}

应该是

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[j * _Width + i] = 32500;
            else
                myVector[j * _Width + i] = 0.5;
        }
}

换句话说，当你计算偏移时，你有i和j错误的方法（或者你应该使用i * _Height + j）。你似乎总是犯同样的错误。

您还有其他错误，例如不遵循三个规则，如克里斯所提到的那样。

释放内存时出错

1 个答案: