동적으로 할당 된 메모리를 사용하는 C++ 곱셈 행렬

Question

동적으로 할당 된 두 행렬 A, B를 곱하는 C++ 함수를 작성하려고합니다. 저는 현재 곱셈 코드가 작동하도록 노력하고 있습니다. 그런 다음 함수로 변환하려고 시도 할 것입니다. 지금 나는 일종의 오류가 발생하고있다. "segmentation fault (코어 덤프)". 나는 그것을 내 코드의 곱셈 부분으로 좁혔지만 무엇이 잘못되었는지는 모른다. 누군가 나를 기쁘게 도와 줄 수 있습니까? 내 코드는 아래와 같습니다.

#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

먼저 매트릭스를 올바르게 할당한다고 말하면서 그 증거는 보이지 않습니다. 포인터 배열을 할당하고 첫 번째 인덱스 인 예를 들어 A[0] 만 초기화합니다. 이것은 잘못되었습니다. 각 행을 할당해야합니다.

당신은이 :

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

당신이 [0] A [rowsA - 1]을 통해 할당해야합니다 ..

다음, 당신의 곱셈 루프 (내부 대부분의 루프가) 잘못되었습니다. 다음과 같아야합니다.

해당 내부 루프에 대해 ColsA를 반복합니다.

당신은이 :

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.. 

     } 
     } 
    } 

다음은 올바른 것 :

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