C++ Matrix Multiplication Program

Beginner
7 min read
Updated: Oct 2026
2 programs
Live preview
Definition

What Is Matrix Multiplication?

Matrix multiplication pairs each row of A with each column of B. If A is m × n and B is n × p, then AB exists and has size m × p.

Remember
A (m × n) × B (n × p) → C (m × p)

C[i][j] = sum over k of  A[i][k] * B[k][j]

Example (2×2):
  [1 2]   [5 6]   [1·5+2·7  1·6+2·8]   [19 22]
  [3 4] × [7 8] = [3·5+4·7  3·6+4·8] = [43 50]

Not the same as cell-by-cell multiply.
A shapeB shapeAllowed?Result
2 × 22 × 2Yes2 × 2
2 × 33 × 2Yes2 × 2
2 × 32 × 2No—
Approach

How to Multiply Matrices in C++

Four clear steps — then code the classic triple loop.

  1. Check that A’s columns equal B’s rows.
  2. Create result C with size rowsA × colsB (zeros by default).
  3. For each i, j, accumulate sum += A[i][k] * B[k][j] over k.
  4. Store that sum in C[i][j].
MethodIdeaTimeBest for
Triple nested loopsDot product of row i and column jO(m × n × p)Interviews, teaching
Shape-safe multiplyValidate inner dimensions firstO(m × n × p)Safer production-style code

Pseudocode

Pseudocode
function Multiply(A, B):
    m = rows of A
    n = cols of A
    p = cols of B

    if n != rows of B:
        error "inner dimensions must match"

    C = new matrix[m][p]   // zeros
    for i from 0 to m - 1:
        for j from 0 to p - 1:
            for k from 0 to n - 1:
                C[i][j] = C[i][j] + A[i][k] * B[k][j]

    return C
Reference

Cheat Sheet

Keep these facts handy while writing the program.

TopicDetail
Shape rulecols(A) == rows(B)
Result sizerows(A) × cols(B)
Cell formulaΣ A[i][k] * B[k][j]
Loopsi rows, j cols, k shared
Not entrywiseDo not confuse with A[i][j] * B[i][j]
Classic check[[1,2],[3,4]] × [[5,6],[7,8]] = [[19,22],[43,50]]
Try it

Live Preview

Pick a sample pair to see A, B, and the product AB.

Tap a chip to run. Inner dimensions always match in these samples.

Result
A (2×2) =
1  2
3  4

B (2×2) =
5  6
7  8

A × B (2×2) =
19 22
43 50
Trace

Worked Walkthrough — 2×2

Each result cell is one row-column dot product.

Calculation
A = [1 2]    B = [5 6]
    [3 4]        [7 8]

C[0][0] = 1·5 + 2·7 = 5 + 14 = 19
C[0][1] = 1·6 + 2·8 = 6 + 16 = 22
C[1][0] = 3·5 + 4·7 = 15 + 28 = 43
C[1][1] = 3·6 + 4·8 = 18 + 32 = 50

Result = [19 22]
         [43 50]
Code

C++ Programs

Start with the classic triple nested loop. Then add an inner-dimension check for safer code.

Example 1 — Triple Nested Loops

Accumulate each result cell as a row-column dot product.

C++
#include <iostream>
using namespace std;

void Multiply(int a[][2], int b[][2], int c[][2], int m, int n, int p)
{
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < p; j++)
        {
            c[i][j] = 0;
            for (int k = 0; k < n; k++)
            {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }
}

void Print(int mat[][2], int rows, int cols)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            cout << mat[i][j] << " ";
        }
        cout << endl;
    }
}

int main()
{
    int a[2][2] = { {1, 2}, {3, 4} };
    int b[2][2] = { {5, 6}, {7, 8} };
    int c[2][2];

    Multiply(a, b, c, 2, 2, 2);
    Print(c, 2, 2);
    return 0;
}

How It Works

  1. m = rows of A, n = shared size, p = columns of B.
  2. Zero each c[i][j] before accumulating the running sum.
  3. Outer i picks the result row; middle j picks the result column.
  4. Inner k walks the shared dimension and adds a[i][k] * b[k][j].
  5. For C[0][0]: 1*5 + 2*7 = 19.

Example 2 — Shape-Safe Multiply

Validate that A’s columns equal B’s rows before multiplying.

C++
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
using namespace std;

vector<vector<int>> Multiply(const vector<vector<int>>& a,
                              const vector<vector<int>>& b)
{
    int m = (int)a.size();
    int n = m > 0 ? (int)a[0].size() : 0;
    int nB = (int)b.size();
    int p = nB > 0 ? (int)b[0].size() : 0;

    if (n != nB)
    {
        throw invalid_argument(
            "A columns (" + to_string(n) + ") must equal B rows (" + to_string(nB) + ").");
    }

    vector<vector<int>> c(m, vector<int>(p, 0));
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < p; j++)
        {
            for (int k = 0; k < n; k++)
            {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    return c;
}

int main()
{
    vector<vector<int>> a = { {1, 2, 3}, {4, 5, 6} };       // 2×3
    vector<vector<int>> b = { {7, 8}, {9, 10}, {11, 12} }; // 3×2
    vector<vector<int>> c = Multiply(a, b);

    for (int i = 0; i < (int)c.size(); i++)
    {
        for (int j = 0; j < (int)c[i].size(); j++)
        {
            cout << c[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

How It Works

  1. Compare A’s column count with B’s row count.
  2. Throw if inner dimensions differ — multiplication is undefined.
  3. Result size is 2 × 2 for a 2×3 times a 3×2.
  4. Same triple loop accumulates each cell.
  5. Check: C[0][0] = 1·7 + 2·9 + 3·11 = 58.

Edge Cases & Pitfalls

Check these before calling the solution done.

Inner dims

Must match

cols(A) == rows(B) or the product is undefined.

Entrywise

Wrong algorithm

Do not write A[i][j] * B[i][j] for true matrix multiply.

Order

AB ≠ BA

Multiplication is not commutative in general.

Overflow

Use long long when needed

Products and sums can exceed INT_MAX.

Analysis

Time and Space Complexity

ProgramTimeExtra space
Triple loopsO(m × n × p)O(1) besides result
Shape-safe multiplyO(m × n × p)O(1) besides result

For square n × n matrices the classic algorithm is O(n³). The result needs O(m × p) space.

Remember

Key Takeaways

  • Rule: cols(A) == rows(B); result is rows(A) × cols(B).
  • Cell: C[i][j] = Σ A[i][k] * B[k][j].
  • Loops: three levels — i, j, then k.
  • Test: [[1,2],[3,4]] × [[5,6],[7,8]] → [[19,22],[43,50]].

One line: each result cell is the dot product of a row of A and a column of B.

Frequently Asked Questions

A’s column count must equal B’s row count. If A is m × n and B is n × p, then AB is m × p.
No. Matrix multiplication uses row-column dot products. Cell-by-cell multiply is a different operation (Hadamard).
One loop picks result row i, one picks column j, and the inner loop accumulates sum over k of A[i][k] * B[k][j].
Not in general. Matrix multiplication is not commutative — AB and BA can differ, and one order may be undefined.
For an m × n matrix times an n × p matrix, classic triple loops cost O(m × n × p). For square n × n matrices that is O(n³).

Next: Matrix Subtraction

Subtract matching cells of two same-sized matrices.

Matrix subtraction tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

10 people found this page helpful

C++ Matrix Division Program C++ Matrix Subtraction Program