C++ multiplying matrices using dynamically allocated memory

Question

I am trying to write a function in C++ that multiplies two matrices A, B which have been dynamically allocated. I am currently trying to get the multiplication code working, then I will attempt to turn it into a function. Right now I am getting an error of sorts; "segmentation fault (core dumped)". I have narrowed it down to the multiplication part of my code but I have no idea what is wrong with it. Can someone help me please? My code is shown below.

    #include <iostream>
    #include <cassert>

    int main()
    {
       int rowsA = 5; // number of rows
       int colsA= 3; // number of coloumns
       // dynamically allocating A
       double** A;
       A = new double* [rowsA];
       A[0] = new double [rowsA*colsA]; 
       for (int i = 1; i < rowsA; i++)
       {
          A[i] = A[i-1] + colsA;
       }

       // Storing elements of matrix A
       for(int i = 0; i < rowsA; ++i)

       {
          for(int j = 0; j < colsA; ++j)

          {

             std::cout << "Enter element A" << i + 1 << j + 1 << " : ";
             std::cin >> A[i][j];

          }
       }

       int rowsB = 3; // number of rows
       int colsB = 5; // number of coloumns
       // dynamically allocating B
       double** B;
       B = new double* [rowsB];
       B[0] = new double [rowsB*colsB]; 
       for (int i = 1; i < rowsB; i++)
       {
          B[i] = B[i-1] + colsB;
       }

       // Storing elements of matrix B
       for(int i = 0; i < rowsB; ++i)

       {
          for(int j = 0; j < colsB; ++j)

          {

             std::cout << "Enter element B" << i + 1 << j + 1 << " : ";
             std::cin >> B[i][j];

          }
       }

       // checking matrix multiplication qualification
       assert(colsA == rowsB);

       // dynamically allocating C
       double** C;
       C = new double* [rowsA];
       C[0] = new double [rowsA*colsB]; 
       for (int i = 1; i < rowsA; i++)
       {
          C[i] = C[i-1] + colsB;
       }

       // Initializing elements of matrix C to 0
       for(int i = 0; i < rowsA; ++i)

       {
          for(int j = 0; j < colsB; ++j)
          {

             C[i][j]=0;

          }
       }

       // multiplication
      for(int i = 0; i < rowsA; ++i)

       {
          for(int j = 0; j < colsB; ++j)

          {
             for(int k = 0; k < colsB; ++k)
             {
                C[i][j] += A[i][k] * B[k][j];

             }
          }
       }

       // Displaying the multiplication of matrices A, B

       std::cout<< "Matrix C: " << std::endl;

       for(int i = 0; i < rowsA; ++i)

       {
          for(int j = 0; j < colsB; ++j)

          {

              std::cout << " " << C[i][j];

              if(j == colsB-1)

              {
                  std::cout << std::endl;

              }
          }
       }
       // deallocation
       delete[] C[0];
       delete[] C;
       delete[] B[0];
       delete[] B;
       delete[] A[0];
       delete[] A;
     }

Answer 1

First, you say you are allocating the matrix properly but I'm not seeing any proof of that. You are allocating an array of pointers and only initializing the first index.. A[0] for example. This is incorrect. You need to allocate EACH ROW.

You have:

double** A;
A = new double* [rowsA];
A[0] = new double [rowsA*colsA]; //Incorrect. You only allocated A[0].

You need to allocate A[0] through A[rowsA - 1]..

Next, your multiplication loop (the inner most loop) is incorrect. It should be:

Iterate ColsA for that inner loop.

You have:

  for(int i = 0; i < rowsA; ++i)
   {
      for(int j = 0; j < colsB; ++j)
      {
         for(int k = 0; k < colsB; ++k) //ColsB is incorrect. Should be colsA..
         {
            C[i][j] += A[i][k] * B[k][j]; //Segfaults here due to bad iteration..

         }
      }
   }

The following would be correct:

#include <iostream>
#include <cassert>

double** create_matrix(int rows, int cols)
{
    double** mat = new double* [rows]; //Allocate rows.
    for (int i = 0; i < rows; ++i)
    {
        mat[i] = new double[cols](); //Allocate each row and zero initialize..
    }
    return mat;
}

void destroy_matrix(double** &mat, int rows)
{
    if (mat)
    {
        for (int i = 0; i < rows; ++i)
        {
            delete[] mat[i]; //delete each row..
        }

        delete[] mat;  //delete the rows..
        mat = nullptr;
    }
}

int main()
{
    int rowsA = 5; // number of rows
    int colsA= 3; // number of coloumns
    double** matA = create_matrix(rowsA, colsA);


    int rowsB = 3; // number of rows
    int colsB = 5; // number of coloumns
    double** matB = create_matrix(rowsB, colsB);


    //Checking matrix multiplication qualification
    assert(colsA == rowsB);


    double** matC = create_matrix(rowsA, colsB);

    //Multiplication
    for(int i = 0; i < rowsA; ++i)
    {
        for(int j = 0; j < colsB; ++j)
        {
            for(int k = 0; k < colsA; ++k) //ColsA..
            {
                matC[i][j] += matA[i][k] * matB[k][j];
            }
        }
    }


    //Clean up..
    destroy_matrix(matA, rowsA);
    destroy_matrix(matB, rowsB);
    destroy_matrix(matC, rowsA);
}