Related Articles
• Difficulty Level : Hard
• Last Updated : 28 Jul, 2020

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up