Skip to content
Related Articles

Related Articles

Improve Article
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



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<vector<int> >& 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<vector<int> >& 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<vector<int> > arr1
        = { { 1, 2, 3 },
            { 4, 5, 6 },
            { 1, 2, 3 } };
  
    vector<vector<int> > 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
Recommended Articles
Page :