C++ Matrix Division Program

Beginner

6 min read

Updated: Oct 2026

2 programs

Live preview

Definition

What Is Matrix Division?

Here matrix division means element-wise division: C[i][j] = A[i][j] / B[i][j]. Both matrices need the same shape, and no cell in B may be zero.

Remember

A ÷ B (entrywise) is defined when shapes match and B has no zeros

  [ 8  6 ]   [ 2  3 ]   [ 4.0  2.0 ]
  [ 9  4 ] ÷ [ 3  2 ] = [ 3.0  2.0 ]

Rule: (A ÷ B)[i][j] = A[i][j] / B[i][j]

Note: this is not A × B⁻¹ from linear algebra.

Position	A	B	A / B
`[0][0]`	`8`	`2`	`4.0`
`[0][1]`	`6`	`3`	`2.0`
`[1][0]`	`9`	`3`	`3.0`
`[1][1]`	`4`	`2`	`2.0`

Approach

How to Divide Matrices in C++

Four clear steps — same nested loops as addition, plus a zero guard.

Confirm both matrices have the same rows and columns.
Reject any zero in B before dividing.
Create a double result matrix of that size.
Set result[i][j] = (double)A[i][j] / B[i][j] for every cell.

Method	Idea	Time	Best for
Nested loops	Divide matching cells into `double`	`O(m × n)`	Interviews, teaching
Safe divide	Validate shape + no zeros in B	`O(m × n)`	Safer production-style code

Pseudocode

function DivideMatrices(A, B):
    rows = rows of A
    cols = cols of A

    if rows != rows of B or cols != cols of B:
        error "shapes must match"

    C = new double matrix[rows][cols]
    for i from 0 to rows - 1:
        for j from 0 to cols - 1:
            if B[i][j] == 0:
                error "division by zero"
            C[i][j] = A[i][j] / B[i][j]

    return C

Reference

Cheat Sheet

Keep these facts handy while writing the program.

Topic	Detail
Rule	`C[i][j] = A[i][j] / B[i][j]`
Requirement	Same shape; `B[i][j] ≠ 0`
Result type	Prefer `double` for decimals
Cast	`(double)a / b` avoids integer truncation
Not inverse	This is not `A × B⁻¹`
Classic check	`[[8,6],[9,4]] ÷ [[2,3],[3,2]] = [[4,2],[3,2]]`

Try it

Live Preview

Pick a sample pair to see matrices A, B, and A ÷ B (entrywise).

Trace

Worked Walkthrough — 2×2

Visit every index once and divide the matching cells.

Calculation

A = [8 6]    B = [2 3]
    [9 4]        [3 2]

i=0, j=0 → 8 / 2 = 4.0
i=0, j=1 → 6 / 3 = 2.0
i=1, j=0 → 9 / 3 = 3.0
i=1, j=1 → 4 / 2 = 2.0

Result = [4.0  2.0]
         [3.0  2.0]

Code

C++ Programs

Start with a clear nested-loop divider using double. Then add shape and zero checks for safer code.

Example 1 — Nested Loops

Divide two same-sized matrices cell by cell into a double result.

C++

#include <iostream>
#include <iomanip>
using namespace std;

void DivideMatrices(int a[][2], int b[][2], double result[][2], int rows, int cols)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            result[i][j] = (double)a[i][j] / b[i][j];
        }
    }
}

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

int main()
{
    int a[2][2] = { {8, 6}, {9, 4} };
    int b[2][2] = { {2, 3}, {3, 2} };
    double result[2][2];

    DivideMatrices(a, b, result, 2, 2);
    Print(result, 2, 2);
    return 0;
}

How It Works

Pass rows and columns so the loops know the bounds.
Allocate a double result so values can hold decimals.
Outer loop chooses row i; inner loop chooses column j.
Cast a[i][j] to double before / so integer division does not truncate.
Print with fixed and setprecision(2) for two decimal places.

Example 2 — Shape & Zero Safe

Validate matching dimensions and reject any zero divisor before dividing.

C++

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

vector<vector<double>> DivideMatrices(const vector<vector<int>>& a,
                                       const vector<vector<int>>& b)
{
    int rows = (int)a.size();
    int cols = rows > 0 ? (int)a[0].size() : 0;

    if ((int)b.size() != rows || (rows > 0 && (int)b[0].size() != cols))
    {
        throw invalid_argument("Matrices must have the same dimensions.");
    }

    vector<vector<double>> result(rows, vector<double>(cols));
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            if (b[i][j] == 0)
            {
                throw runtime_error("B[" + to_string(i) + "][" + to_string(j) + "] is zero.");
            }
            result[i][j] = (double)a[i][j] / b[i][j];
        }
    }
    return result;
}

int main()
{
    vector<vector<int>> a = { {10, 9, 8}, {6, 5, 4} };
    vector<vector<int>> b = { {2, 3, 4}, {2, 1, 2} };
    vector<vector<double>> q = DivideMatrices(a, b);

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

How It Works

Compare both dimensions; throw if shapes differ.
Before each division, check b[i][j] == 0.
Throw runtime_error with the failing index.
Otherwise store (double)a[i][j] / b[i][j].
Mention both checks in interviews — shape and zero are the two traps.

Edge Cases & Pitfalls

Check these before calling the solution done.

Zero in B

Never divide

Guard every B[i][j] before using /.

int / int

Cast to double

Without a cast, 5 / 2 becomes 2, not 2.5.

Shape

Must match

Different sizes cannot be divided entrywise.

Inverse

Different topic

True matrix division via B⁻¹ is not this algorithm.

Analysis

Time and Space Complexity

Program	Time	Extra space
Nested loops	`O(m × n)`	`O(1)` besides result
Shape & zero safe	`O(m × n)`	`O(1)` besides result

Every cell is touched exactly once. The result matrix needs O(m × n) space.

Remember

Key Takeaways

Rule: divide matching cells; shapes must match.
Guard: never divide by a zero in B.
Type: use double and cast before /.
Test: [[8,6],[9,4]] ÷ [[2,3],[3,2]] → [[4,2],[3,2]].

One line: same shape, nonzero B — then C[i][j] = A[i][j] / B[i][j].

Frequently Asked Questions

What does matrix division mean here?

Element-wise division: result[i][j] = A[i][j] / B[i][j]. Both matrices must have the same shape, and B must not contain zeros.

Is this the same as textbook matrix division?

Usually not. In higher math, matrix division often means multiplying by an inverse. This page uses simpler cell-by-cell division.

Why use double?

Division often produces decimals (for example 5 / 2 = 2.5). A double result keeps fractional values visible.

What if B has a zero?

Division by zero is invalid. Check B first and throw (or skip) before dividing.

What is the time complexity?

For an m × n matrix, each cell is visited once, so time is O(m × n).

Next: Matrix Multiplication

Multiply matrices with row-column dot products.

Matrix multiplication tutorial →

About the author

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)

7 people found this page helpful

C++ Matrix Addition Program C++ Matrix Multiplication Program

C++ Matrix Division Program

What Is Matrix Division?

How to Divide Matrices in C++

Pseudocode

Cheat Sheet

Live Preview

Worked Walkthrough — 2×2

C++ Programs

Example 1 — Nested Loops

How It Works

Example 2 — Shape & Zero Safe

How It Works

Edge Cases & Pitfalls

Never divide

Cast to double

Must match

Different topic

Time and Space Complexity

Key Takeaways

Frequently Asked Questions

Related Topics

Interview Hub

Matrix Addition

Matrix Multiplication

Matrix Subtraction

Next: Matrix Multiplication

About the author