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
Subtraction 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
Subtraction 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

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 as global and M2[][] is passed as an argument to the function “void Matrix::operator+(Matrix x)“.

In the above overloaded function, the approach 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 approach for subtraction 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 approach 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)` `{`   `    ``// Traverse 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];`   `    ``// Traverse 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];`   `    ``// Traverse 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];`   `    ``// Traverse 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 subtraction of matrix` `    ``cout << ``"Subtraction of two given"` `         ``<< ``" Matrices is : \n"``;` `    ``mat1 - mat2;`   `    ``// For multiplication of matrix` `    ``cout << ``"Multiplication of two"` `         ``<< ``" given Matrices is : \n"``;` `    ``mat1* mat2;`   `    ``return` `0;` `}`

Java

 `import` `java.util.*;`   `public` `class` `Matrix {`   `    ``int` `arr[][];` `    ``int` `N;`   `    ``// Constructor to initialize` `    ``// Matrix object` `    ``public` `Matrix(``int` `n)` `    ``{` `        ``N = n;` `        ``arr = ``new` `int``[N][N];` `    ``}`   `    ``// Function to take input to arr[][]` `    ``void` `input(List > A)` `    ``{`   `        ``// Traverse the List A[][]` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``for` `(``int` `j = ``0``; j < N; j++) {` `                ``arr[i][j] = A.get(i).get(j);` `            ``}` `        ``}` `    ``}`   `    ``// Function to display the element of Matrix` `    ``void` `display()` `    ``{`   `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``for` `(``int` `j = ``0``; j < N; j++) {` `                ``// Print the element` `                ``System.out.print(arr[i][j] + ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Function for addition of two Matrix using operator` `    ``// overloading` `    ``void` `add(Matrix x)` `    ``{`   `        ``// To store the sum of Matrices` `        ``int` `mat[][] = ``new` `int``[N][N];`   `        ``// Traverse 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` `                ``System.out.print(mat[i][j] + ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Function for subtraction of two Matrix using operator` `    ``// overloading` `    ``void` `subtract(Matrix x)` `    ``{`   `        ``// To store the difference of Matrices` `        ``int` `mat[][] = ``new` `int``[N][N];`   `        ``// Traverse 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` `                ``System.out.print(mat[i][j] + ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Function for multiplication of two Matrix using` `    ``// operator overloading` `    ``public` `void` `multiply(Matrix x)` `    ``{` `        ``// To store the multiplication` `        ``// of Matrices` `        ``int``[][] mat = ``new` `int``[N][N];`   `        ``// Traverse 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` `                ``System.out.print(mat[i][j] + ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}` `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Dimension of Matrix` `        ``int` `N = ``3``;`   `        ``List > arr1 = Arrays.asList(` `            ``Arrays.asList(``1``, ``2``, ``3``), Arrays.asList(``4``, ``5``, ``6``),` `            ``Arrays.asList(``1``, ``2``, ``3``));`   `        ``List > arr2 = Arrays.asList(` `            ``Arrays.asList(``1``, ``2``, ``3``), Arrays.asList(``4``, ``5``, ``16``),` `            ``Arrays.asList(``1``, ``2``, ``3``));`   `        ``// Declare Matrices` `        ``Matrix mat1 = ``new` `Matrix(N);` `        ``Matrix mat2 = ``new` `Matrix(N);`   `        ``// Take Input to matrix mat1` `        ``mat1.input(arr1);`   `        ``// Take Input to matrix mat2` `        ``mat2.input(arr2);`   `        ``// For addition of matrix` `        ``System.out.println(` `            ``"Addition of two given Matrices is : "``);` `        ``mat1.add(mat2);`   `        ``// For subtraction of matrix` `        ``System.out.println(` `            ``"Subtraction of two given Matrices is : "``);` `        ``mat1.subtract(mat2);`   `        ``// For multiplication of matrix` `        ``System.out.println(` `            ``"Multiplication of two given Matrices is : "``);` `        ``mat1.multiply(mat2);` `    ``}` `}`

Python3

 `# Python program for the above approach`   `# Dimension of Matrix` `N ``=` `3` `rows ``=` `50` `cols ``=` `50`   `# Class for Matrix operator overloading` `class` `Matrix:` `    ``def` `__init__(``self``):` `        `  `        ``# For input Matrix` `        ``self``.arr ``=` `[[``0` `for` `i ``in` `range``(cols)] ``for` `j ``in` `range``(rows)]`   `    ``# Functions to get input to Matrix` `    ``# array arr[][]` `    ``def` `input``(``self``, A):` `        `  `        ``# Traverse the vector A[][]` `        ``for` `i ``in` `range``(N):` `            ``for` `j ``in` `range``(N):` `                ``self``.arr[i][j] ``=` `A[i][j]`   `    ``# Function to display the element` `    ``# of Matrix` `    ``def` `display(``self``):` `        ``for` `i ``in` `range``(N):` `            ``for` `j ``in` `range``(N):` `                `  `                ``# Print the element` `                ``print``(``self``.arr[i][j], end``=``' '``)` `            ``print``()`   `    ``# Function for addition of two Matrix` `    ``# using operator overloading` `    ``def` `__add__(``self``, x):` `        `  `        ``# To store the sum of Matrices` `        ``mat ``=` `[[``0` `for` `i ``in` `range``(N)] ``for` `j ``in` `range``(N)]` `        ``for` `i ``in` `range``(N):` `            ``for` `j ``in` `range``(N):` `                `  `                ``# Add the corresponding` `                ``# blocks of Matrices` `                ``mat[i][j] ``=` `self``.arr[i][j] ``+` `x.arr[i][j]` `            `  `        ``# Display the sum of Matrices` `        ``for` `i ``in` `range``(N):` `            ``for` `j ``in` `range``(N):` `                `  `                ``# Print the element` `                ``print``(mat[i][j], end``=``' '``)` `            ``print``()`   `    ``# Function for subtraction of two Matrix` `    ``# using operator overloading` `    ``def` `__sub__(``self``, x):` `        `  `        ``# To store the difference of Matrices` `        ``mat ``=` `[[``0` `for` `i ``in` `range``(N)] ``for` `j ``in` `range``(N)]` `        `  `        ``# Traverse the Matrix x` `        ``for` `i ``in` `range``(N):` `            ``for` `j ``in` `range``(N):` `                `  `                ``# Subtract the corresponding` `                ``# blocks of Matrices` `                ``mat[i][j] ``=` `self``.arr[i][j] ``-` `x.arr[i][j]` `                `  `        ``# Display the difference of Matrices` `        ``for` `i ``in` `range``(N):` `            ``for` `j ``in` `range``(N):` `                `  `                ``# Print the element` `                ``print``(mat[i][j], end``=``' '``)` `            ``print``()`   `    ``# Function for multiplication of` `    ``# two Matrix using operator` `    ``# overloading` `    ``def` `__mul__(``self``, x):` `        `  `        ``# To store the multiplication` `        ``# of Matrices` `        ``mat ``=` `[[``0` `for` `i ``in` `range``(N)] ``for` `j ``in` `range``(N)]` `        `  `        ``# Traverse the Matrix x` `        ``for` `i ``in` `range``(N):` `            ``for` `j ``in` `range``(N):` `                `  `                ``# Initialise current block` `                ``# with value zero` `                ``mat[i][j] ``=` `0` `                `  `                ``for` `k ``in` `range``(N):` `                    ``mat[i][j] ``+``=` `self``.arr[i][k] ``*` `(x.arr[k][j])` `        `  `        ``# Display the multiplication` `        ``# of Matrices` `        ``for` `i ``in` `range``(N):` `            ``for` `j ``in` `range``(N):` `                `  `                ``# Print the element` `                ``print``(mat[i][j], end``=``' '``)` `            ``print``()`   `# Driver Code` `arr1 ``=` `[[``1``, ``2``, ``3``],` `        ``[``4``, ``5``, ``6``],` `        ``[``1``, ``2``, ``3``]]`   `arr2 ``=` `[[``1``, ``2``, ``3``],` `        ``[``4``, ``5``, ``16``],` `        ``[``1``, ``2``, ``3``]]`   `# Declare Matrices` `mat1 ``=` `Matrix()` `mat2 ``=` `Matrix()`   `# Take Input to matrix mat1` `mat1.``input``(arr1)`   `# Take Input to matrix mat2` `mat2.``input``(arr2)`   `# For addition of matrix` `print``(``"Addition of two given Matrices is : "``)` `mat1 ``+` `mat2`   `# For subtraction of matrix` `print``(``"Subtraction of two given Matrices is : "``)` `mat1 ``-` `mat2`   `# For multiplication of matrix` `print``(``"Multiplication of two given Matrices is : "``)` `mat1 ``*` `mat2`

Javascript

 `function` `matrixAddition(matrix1, matrix2) {` `  ``var` `result = [];`   `  ``for` `(``var` `i = 0; i < matrix1.length; i++) {` `    ``var` `row = [];`   `    ``for` `(``var` `j = 0; j < matrix1[i].length; j++) {` `      ``row.push(matrix1[i][j] + matrix2[i][j]);` `    ``}`   `    ``result.push(row.join(``" "``));` `  ``}`   `  ``return` `result.join(``"\n"``);` `}`   `function` `matrixSubtraction(matrix1, matrix2) {` `  ``var` `result = [];`   `  ``for` `(``var` `i = 0; i < matrix1.length; i++) {` `    ``var` `row = [];`   `    ``for` `(``var` `j = 0; j < matrix1[i].length; j++) {` `      ``row.push(matrix1[i][j] - matrix2[i][j]);` `    ``}`   `    ``result.push(row.join(``" "``));` `  ``}`   `  ``return` `result.join(``"\n"``);` `}`   `function` `matrixMultiplication(matrix1, matrix2) {` `  ``var` `result = [];`   `  ``for` `(``var` `i = 0; i < matrix1.length; i++) {` `    ``var` `row = [];`   `    ``for` `(``var` `j = 0; j < matrix2[0].length; j++) {` `      ``var` `sum = 0;`   `      ``for` `(``var` `k = 0; k < matrix1[0].length; k++) {` `        ``sum += matrix1[i][k] * matrix2[k][j];` `      ``}`   `      ``row.push(sum);` `    ``}`   `    ``result.push(row.join(``" "``));` `  ``}`   `  ``return` `result.join(``"\n"``);` `}`   `var` `matrix1 = [` `  ``[1, 2, 3],` `  ``[4, 5, 6],` `  ``[1, 2, 3]` `];`   `var` `matrix2 = [` `  ``[1, 2, 3],` `  ``[4, 5, 16],` `  ``[1, 2, 3]` `];`   `console.log(``"Addition of two given Matrices is: "``);` `console.log(matrixAddition(matrix1, matrix2));` `console.log(``"\n"``);`   `console.log(``"Subtraction of two given Matrices is: "``);` `console.log(matrixSubtraction(matrix1, matrix2));` `console.log(``"\n"``);`   `console.log(``"Multiplication of two given Matrices is: "``);` `console.log(matrixMultiplication(matrix1, matrix2));` `console.log(``"\n"``);`

Output

```Addition of two given Matrices is :
2 4 6
8 10 22
2 4 6
Subtraction 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 ```

Time Complexity:

The time complexity of the input() function is O(N^2) because it has to traverse the entire input matrix/vector of size NxN.
The time complexity of the display() function is also O(N^2) because it has to print all the elements of the matrix/vector.
The time complexity of the operator overloading functions for addition, subtraction, and multiplication of two matrices is O(N^3) because for each element in the output matrix, we need to calculate the sum/difference/product of N elements from the input matrices.
Therefore, the overall time complexity of the program is O(N^3) for each operator overload.

Auxiliary Space: O(N^2) because we need to store two matrices of size NxN in memory, which takes up O(N^2) space.