Question

This is my code:

linearMatrix lAmatrixmatrixmult(const linearMatrix &A,
                             const linearMatrix &B)
{
    //Local variables
    int W_A = A.Get_Width;
    int H_A = A.Get_Height;

    int H_B = B.Get_Height;
    int W_B = B.Get_Width;

    float *vectorA;
    float *vectorB;
    float *vectorC;
    //================

    //Memory allocation
    try{
        vectorA = new float[W_A * H_A];
    }
    catch(bad_alloc &ex)
    {
        cerr << "Exception:" << ex.what();
        exit(1);
    }

    try{
        vectorB = new float[W_B * H_B];
    }
    catch(bad_alloc &ex)
    {
        cerr << "Exception:" << ex.what();
        exit(1);
    }

    try{
        vectorC = new float[W_A * H_B];
    }
    catch(bad_alloc &ex)
    {
        cerr << "Exception:" << ex.what();
        exit(1);
    }
    //=================

    //Initialization
    vectorA = A.Get_Vector;
    vectorB = B.Get_Vector;
    //==============

    if(W_A == H_B)
    {
        linearMatrix C(W_A, H_B);

        for(int i = 0; i < W_A; i++)
        {
            for(int j = 0; j < W_B; j++)
            {
                float sum = 0;
                for(int k = 0; k < W_A; k++)
                {
                    float a = vectorA[i * W_A + k];
                    float b = vectorB[k * H_B + j];
                    sum += a * b;
                }
            vectorC[i * W_A + j] = sum;
            }
        }
        C.Set_Vector(vectorC, W_A, H_B);

        //Free memory
        delete [] vectorA;
        delete [] vectorB;
        delete [] vectorC;
        //===========

        return C;
    }
    else
    {
        cout << "Different sizes! Cannot perform mmmult" << endl;

        //Free memory
        delete [] vectorA;
        delete [] vectorB;
        delete [] vectorC;
        //===========

        exit(1);
    }
}

And the ~linearMatrix is:

//Destructor definition
linearMatrix::~linearMatrix()
{
    delete [] myVector;
}

Where linearMatrix is:

class linearMatrix
{
public:
    //Constructor
    linearMatrix(const int Width, const int Heigth);

    //Copy constructor
    linearMatrix(const linearMatrix &that);

    //Copy assignment operator
    linearMatrix& operator=(const linearMatrix& that);

    //Destroyer
    ~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);

    //Set a float *vector
    void Set_Vector(const float *V, const int Width, const int Heigth);

    //Show a little vector
    void Show_Little_Matrix(void);

    //Get the vector
    //Suppose V is previously allocated
    float *Get_Vector(void);

    //Get total number of elements
    int Get_NumberofElements(void);

    //Get Width
    int Get_Width(void);

    //Get Height
    int Get_Height(void);

private:
    int myWidth, myHeight; // Width and Height
    float* myVector;

    //Aux function for testing
    bool Test_Sizes(const int Width, const int Heigth);
};

Must I free memory before leaving a function if I used the new operator inside a function? Should I free memory before any exit() call?

Answer 1

No, that is not correct:

vectorA = new float[W_A * H_A]; // allocates memory
vectorA = A.Get_Vector();       // allocated memory is leaked
                                // vectorA now points to memory owned by A
delete [] vectorA;              // delete memory owned by A

Of course, in C++ you would normally just use std::vector<float>.