Matrix Multiplication in C++

Matrix Multiplication in C++ (Multiply Two Matrix).

IntermediateArray Operations ProgramsExample 6 of 7

matrix-multiplication.cpp

1#include <iostream>
2using namespace std;
3
4int main() {
5    int rows1 = 2, cols1 = 3;
6    int rows2 = 3, cols2 = 2;
7    
8    int matrix1[2][3] = {{1, 2, 3}, {4, 5, 6}};
9    int matrix2[3][2] = {{7, 8}, {9, 10}, {11, 12}};
10    int result[2][2] = {{0, 0}, {0, 0}};
11    
12    // Matrix multiplication
13    for (int i = 0; i < rows1; i++) {
14        for (int j = 0; j < cols2; j++) {
15            for (int k = 0; k < cols1; k++) {
16                result[i][j] += matrix1[i][k] * matrix2[k][j];
17            }
18        }
19    }
20    
21    cout << "Result matrix:" << endl;
22    for (int i = 0; i < rows1; i++) {
23        for (int j = 0; j < cols2; j++) {
24            cout << result[i][j] << " ";
25        }
26        cout << endl;
27    }
28    
29    return 0;
30}

Output

Result matrix:
58 64
139 154

What's going on

The program multiplies two matrices and displays the result. For example:

Matrix 1 (2x3):

1 2 3

4 5 6

Matrix 2 (3x2):

7 8

9 10

11 12

Result (2x2):

58 64

139 154

Matrix multiplication is not commutative (A×B ≠ B×A in general).

Header File Used

This header provides:

cout for displaying output

cin for taking input from the user

1#include <iostream>

Understanding Matrix Multiplication Rules

Dimension Requirement

For matrices A (m×n) and B (p×q) to be multipliable:

Number of columns in A must equal number of rows in B

That is: n = p

Result Dimensions

Result matrix will be m x q

Example: (2 x 3) x (3 x 2) = (2 x 2)

Multiplication Process

Element at result[i][j] = sum of (A[i][k] * B[k][j]) for all k

This is the dot product of row i of A and column j of B

Declaring Variables

The program declares:

int rows1 = 2, cols1 = 3;

int rows2 = 3, cols2 = 2;

int matrix1[2][3] = {{1, 2, 3}, {4, 5, 6}};

int matrix2[3][2] = {{7, 8}, {9, 10}, {11, 12}};

int result[2][2] = {{0, 0}, {0, 0}};

rows1, cols1: dimensions of first matrix (2×3)

rows2, cols2: dimensions of second matrix (3×2)

matrix1: first matrix

matrix2: second matrix

result: stores the multiplication result (2×2)

The Matrix Multiplication Algorithm

The core algorithm uses three nested loops:

for (int i = 0; i < rows1; i++) {

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

for (int k = 0; k < cols1; k++) {

result[i][j] += matrix1[i][k] * matrix2[k][j];

}

How it works

Outer loop (i): iterates through rows of result matrix (rows1)

Middle loop (j): iterates through columns of result matrix (cols2)

Inner loop (k): iterates through common dimension (cols1 = rows2)

result[i][j] accumulates: matrix1[i][k] × matrix2[k][j]

Step-by-step calculation

(for result[0][0]):

k = 0:

result[0][0] += matrix1[0][0] * matrix2[0][0] = 1 * 7 = 7

k = 1:

result[0][0] += matrix1[0][1] * matrix2[1][0] = 2 * 9 = 18

k = 2:

result[0][0] += matrix1[0][2] * matrix2[2][0] = 3 * 11 = 33

Final:

result[0][0] = 7 + 18 + 33 = 58

Visual Representation

result[0][0] = (1*7) + (2*9) + (3*11) = 7 + 18 + 33 = 58

result[0][1] = (1*8) + (2*10) + (3*12) = 8 + 20 + 36 = 64

result[1][0] = (4*7) + (5*9) + (6*11) = 28 + 45 + 66 = 139

result[1][1] = (4*8) + (5*10) + (6*12) = 32 + 50 + 72 = 154

Understanding the Dot Product

Dot Product Concept

Each element in the result is the dot product of:

A row from the first matrix

A column from the second matrix

Example

(result[0][0]):

Row 0 of matrix1: [1, 2, 3]

Column 0 of matrix2: [7, 9, 11]

Dot product: (1*7) + (2*9) + (3*11) = 58

Displaying the Result

The program displays the result matrix:

for (int i = 0; i < rows1; i++) {

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

}

cout << endl;

}

Output:

58 64

139 154

1cout << result[i][j] << " ";

Important Matrix Multiplication Properties

Not Commutative

A * B != B * A (in general)

Order matters!

Associative

(A * B) * C = A * (B * C)

You can group multiplications

Distributive

A * (B + C) = A * B + A * C

Multiplication distributes over addition

Identity Matrix

I * A = A * I = A

Multiplying by identity matrix gives original matrix

When to Use Matrix Multiplication

Linear Algebra

Solving systems of linear equations

Matrix transformations

Eigenvalue calculations

Computer Graphics

3D transformations (rotation, scaling, translation)

Coordinate system conversions

Projection matrices

Machine Learning

Neural network computations

Feature transformations

Data processing pipelines

Scientific Computing

Numerical methods

Signal processing

Image processing

Important Considerations

Dimension Compatibility

Always check: cols1 == rows2

If not compatible, multiplication is undefined

Initialization

Initialize result matrix to zeros

Important for accumulation: result[i][j] += ...

Time Complexity

O(rows1 * cols2 * cols1) for standard algorithm

For n x n matrices: O(n^3)

Can be optimized using algorithms like Strassen's

Memory Requirements

Result matrix requires rows1 × cols2 space

For large matrices, consider memory constraints

Common Mistakes

Wrong Loop Order

Must be: i (rows1), j (cols2), k (cols1)

Wrong order produces incorrect results

Not Initializing Result

Result matrix must be initialized to zeros

Otherwise, contains garbage values

Dimension Mismatch

Not checking if cols1 == rows2

Leads to undefined behavior

return 0;

This ends the program successfully.

PreviousTranspose of a Matrix NextDisplay Factors of a Number