C++ 中的二维矩阵乘法

Question

I want to write a function which allows us to do multiplication of 2 2D matrices. This function has the following parameters as inputs: list1 and list2 are 2D arrays. They are transferred to the function as pointers. Row1, col1, row2, col2 are int values for the size of list1 and list2.

When I have square matrices for the inputs I get correct results. For example; list1[2][2] = {1,2,3,4} and list2[2][2] = {1,2,3,4} gives the result {7,10,15,22}.

When I don't use square matrices I don't get correct results. For example; list1[2][1] = {1,2} and list2[1][2] = {1,2} gives the result {1,4,4,0} which is wrong and list1[2][1] = {1,2} and list2[1][2] = {1,2} gives a garbage value instead of a scalar number.

EDIT : Fixed the returning pointer problem but I still don't get the correct result

#include <iostream>

using namespace std;

void printArray2D(int* list, int row, int col) {
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            cout << list[i * col + j] << " ";
        }
        cout << "" << endl;
    }
}

int* matrixMultiplication(int* list1, int* list2, int row1, int col1, int row2, int col2) {
    if (col1 != row2) {
        cout << "Array sizes don't match";
        return NULL;
    }
    else {
        int* newList = new int[5];
        newList[0] = 0;
        newList[1] = 0;
        newList[2] = 0;
        newList[3] = 0;
        newList[4] = 0;
        for (int i = 0; i < row1; i++) {
            for (int j = 0; j < col2; j++) {
                for (int k = 0; k < col1; k++) {
                    newList[i * col1 + j] = newList[i * col1 + j] + list1[i * col1 + k] * list2[k * col1 + j];
                }
            }
        }
        return newList;
    }
}

int main()
{
    int list1[2][1] = {1,2};

    int list2[1][2] = {1,2};
    

    int row1 = sizeof(list1) / sizeof(list1[0]);
    
    int col1 = sizeof(list1[0]) / sizeof(list1[0][0]);

    int row2 = sizeof(list2) / sizeof(list2[0]);

    int col2 = sizeof(list2[0]) / sizeof(list2[0][0]);
   

    int* result = matrixMultiplication((int*)list1, (int*)list2, row1, col1, row2, col2);

    printArray2D((int*)result, row1, col2);

    return 0;
}

Answer 1

I wouldn't mix in one function two entirely different matters, a memory allocation and a matrix-matrix multiplication!

I would do C = A * B like this:

bool matrixMultiplication(int* C, int* A, int * B, int rowA, int colA, int rowB, int colB) {

    if (colA != rowB) return true;

    for (int i = 0; i < rowA; i++)
        for (int j = 0; j < colB; j++)
            for (int k = 0; k < colA; k++)
                C[i*colB + j] += A[i*colA + k] * B[k*colB + j];

    return false;
}

so, in the main script have something like this:

bool error = matrixMultiplication( /* parameters */ );
if ( error ) {
    std::cout << "invalid matrix dimensions" << std::endl;
    return 0;
}

It is generally a VERY BAD idea to hide memory allocations under routines in this way! Design the code better by separation of concerns. The scope of the routine is to multiply two matrices A and B , and store results to C .

Note:

1. Make sure that all values under C are set to zero, in advance!

2. We have a disagreement in our choices about this line: C[i*colB + j] += A[i*colA + k] * B[k*colB + j];