Matrix operations using operator overloading

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


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

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.