Related Articles
Matrix operations using operator overloading
• Difficulty Level : Hard
• Last Updated : 28 Jul, 2020

Pre-requisite: Operator Overloading

Given two matrix mat1[][] and mat2[][] of NxN dimensions, the task is to perform Matrix Operations using Operator Overloading.

Examples:

Input: arr1[][] = { {1, 2, 3}, {4, 5, 6}, {1, 2, 3}}, arr2[][] = { {1, 2, 3}, {4, 5, 16}, {1, 2, 3}}
Output:
Addition of two given Matrices is:
2 4 6
8 10 22
2 4 6
Substraction of two given Matrices is:
0 0 0
0 0 -10
0 0 0
Multiplication of two given Matrices is:
12 18 44
30 45 110
12 18 44

Input: arr1[][] = { {11, 2, 3}, {4, 5, 0}, {1, 12, 3}}, arr2[][] = { {1, 2, 3}, {41, 5, 16}, {1, 22, 3}}
Output:
Addition of two given Matrices is :
12 4 6
45 10 16
2 34 6
Substraction of two given Matrices is :
10 0 0
-37 0 -16
0 -10 0
Multiplication of two given Matrices is :
96 98 74
209 33 92
496 128 204

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
To overload +, , * operators, we will create a class named matrix and then make a public function to overload the operators.

• To overload operator ‘+’ use prototype:
```Return_Type classname :: operator +(Argument list)
{
// Function Body
}
```

For Example:

Let there are two matrix M1[][] and M2[][] of same dimensions. Using Operator Overloading M1[][] and M2[][] can be added as M1 + M2.

In the above statement M1 is treated hai global and M2[][] is passed as an argument to the function “void Matrix::operator+(Matrix x)“.

In the above overloaded function, the appproach for addition of two matrix is implemented by treating M1[][] as first and M2[][] as second Matrix i.e., Matrix x(as the arguments).

• To overload operator ‘-‘ use prototype:
```Return_Type classname :: operator -(Argument list)
{
// Function Body
}
```

For Example:

Let there are two matrix M1[][] and M2[][] of same dimensions. Using Operator Overloading M1[][] and M2[][] can be added as M1 – M2.

In the above statement M1 is treated hai global and M2[][] is passed as an argument to the function “void Matrix::operator-(Matrix x)“.

In the above overloaded function, the appproach for substraction of two matrix is implemented by treating M1[][] as first and M2[][] as second Matrix i.e., Matrix x(as the arguments).

• To overload operator ‘*’ use prototype:
```Return_Type classname :: operator *(Argument list)
{
// Function Body
}
```

Let there are two matrix M1[][] and M2[][] of same dimensions. Using Operator Overloading M1[][] and M2[][] can be added as M1 * M2.

In the above statement M1 is treated hai global and M2[][] is passed as an argument to the function “void Matrix::operator*(Matrix x)“.

In the above overloaded function, the appproach for multiplication of two matrix is implemented by treating M1[][] as first and M2[][] as second Matrix i.e., Matrix x(as the arguments).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`` ` `#include "bits/stdc++.h"``#define rows 50``#define cols 50``using` `namespace` `std;`` ` `int` `N;`` ` `// Class for Matrix operator overloading``class` `Matrix {`` ` `    ``// For input Matrix``    ``int` `arr[rows][cols];`` ` `public``:``    ``// Function to take input to arr[][]``    ``void` `input(vector >& A);``    ``void` `display();`` ` `    ``// Functions for operator overloading``    ``void` `operator+(Matrix x);``    ``void` `operator-(Matrix x);``    ``void` `operator*(Matrix x);``};`` ` `// Functions to get input to Matrix``// array arr[][]``void` `Matrix::input(vector >& A)``{`` ` `    ``// Travarse the vector A[][]``    ``for` `(``int` `i = 0; i < N; i++) {`` ` `        ``for` `(``int` `j = 0; j < N; j++) {`` ` `            ``arr[i][j] = A[i][j];``        ``}``    ``}``}`` ` `// Function to display the element``// of Matrix``void` `Matrix::display()``{`` ` `    ``for` `(``int` `i = 0; i < N; i++) {`` ` `        ``for` `(``int` `j = 0; j < N; j++) {`` ` `            ``// Print the element``            ``cout << arr[i][j] << ``' '``;``        ``}``        ``cout << endl;``    ``}``}`` ` `// Function for addition of two Matrix``// using operator overloading``void` `Matrix::operator+(Matrix x)``{``    ``// To store the sum of Matrices``    ``int` `mat[N][N];`` ` `    ``// Travarse the Matrix x``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {`` ` `            ``// Add the corresponding``            ``// blocks of Matrices``            ``mat[i][j] = arr[i][j]``                        ``+ x.arr[i][j];``        ``}``    ``}`` ` `    ``// Display the sum of Matrices``    ``for` `(``int` `i = 0; i < N; i++) {`` ` `        ``for` `(``int` `j = 0; j < N; j++) {`` ` `            ``// Print the element``            ``cout << mat[i][j] << ``' '``;``        ``}``        ``cout << endl;``    ``}``}`` ` `// Function for subtraction of two Matrix``// using operator overloading``void` `Matrix::operator-(Matrix x)``{``    ``// To store the difference of Matrices``    ``int` `mat[N][N];`` ` `    ``// Travarse the Matrix x``    ``for` `(``int` `i = 0; i < N; i++) {`` ` `        ``for` `(``int` `j = 0; j < N; j++) {`` ` `            ``// Subtract the corresponding``            ``// blocks of Matrices``            ``mat[i][j] = arr[i][j]``                        ``- x.arr[i][j];``        ``}``    ``}`` ` `    ``// Display the difference of Matrices``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {`` ` `            ``// Print the element``            ``cout << mat[i][j] << ``' '``;``        ``}``        ``cout << endl;``    ``}``}`` ` `// Function for multiplication of``// two Matrix using operator``// overloading``void` `Matrix::operator*(Matrix x)``{``    ``// To store the multiplication``    ``// of Matrices``    ``int` `mat[N][N];`` ` `    ``// Travarse the Matrix x``    ``for` `(``int` `i = 0; i < N; i++) {`` ` `        ``for` `(``int` `j = 0; j < N; j++) {`` ` `            ``// Initialise current block``            ``// with value zero``            ``mat[i][j] = 0;`` ` `            ``for` `(``int` `k = 0; k < N; k++) {``                ``mat[i][j] += arr[i][k]``                             ``* (x.arr[k][j]);``            ``}``        ``}``    ``}`` ` `    ``// Display the multiplication``    ``// of Matrices``    ``for` `(``int` `i = 0; i < N; i++) {`` ` `        ``for` `(``int` `j = 0; j < N; j++) {`` ` `            ``// Print the element``            ``cout << mat[i][j] << ``' '``;``        ``}``        ``cout << endl;``    ``}``}`` ` `// Driver Code``int` `main()``{`` ` `    ``// Dimension of Matrix``    ``N = 3;`` ` `    ``vector > arr1``        ``= { { 1, 2, 3 },``            ``{ 4, 5, 6 },``            ``{ 1, 2, 3 } };`` ` `    ``vector > arr2``        ``= { { 1, 2, 3 },``            ``{ 4, 5, 16 },``            ``{ 1, 2, 3 } };`` ` `    ``// Declare Matrices``    ``Matrix mat1, mat2;`` ` `    ``// Take Input to matrix mat1``    ``mat1.input(arr1);`` ` `    ``// Take Input to matrix mat2``    ``mat2.input(arr2);`` ` `    ``// For addition of matrix``    ``cout << ``"Addition of two given"``         ``<< ``" Matrices is : \n"``;``    ``mat1 + mat2;`` ` `    ``// For substraction of matrix``    ``cout << ``"Substraction of two given"``         ``<< ``" Matrices is : \n"``;``    ``mat1 - mat2;`` ` `    ``// For multiplication of matrix``    ``cout << ``"Multiplication of two"``         ``<< ``" given Matrices is : \n"``;``    ``mat1* mat2;`` ` `    ``return` `0;``}`
Output:
```Addition of two given Matrices is :
2 4 6
8 10 22
2 4 6
Substraction of two given Matrices is :
0 0 0
0 0 -10
0 0 0
Multiplication of two given Matrices is :
12 18 44
30 45 110
12 18 44
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up