Write A C++ Program To Add Two Matrix Using Class

In this article, you will learn how to design and implement a C++ program to add two matrices using object-oriented principles, specifically by creating a Matrix class.

Problem Statement

Matrix addition is a fundamental operation in linear algebra, widely used in various scientific and engineering applications. The challenge lies in efficiently representing matrices and defining an operation for their addition, ensuring correct dimensions and memory management. We need a structured way to handle matrix data, typically 2D arrays, and perform element-wise summation of two matrices of the same dimensions to produce a resultant matrix.

Example

Consider two 2x2 matrices, A and B:

Matrix A:

1 2
3 4

Matrix B:

5 6
7 8

Adding these two matrices should produce a new matrix C:

Matrix C (A + B):

(1+5) (2+6)    6 8
(3+7) (4+8) = 10 12

Background & Knowledge Prerequisites

To understand this implementation, readers should be familiar with:

• C++ Basics: Fundamental syntax, data types, loops, and conditional statements.
• Classes and Objects: Concepts of encapsulation, member variables, member functions, constructors, and destructors.
• Dynamic Memory Allocation: Using new and delete for arrays.
• Two-Dimensional Arrays: How to declare and manipulate them in C++.
• Operator Overloading: How to redefine standard operators for custom classes.

Relevant setup information:

• A C++ compiler (e.g., g++, clang) is required to compile and run the code.

Use Cases or Case Studies

Matrix addition is a cornerstone operation in many fields:

• Computer Graphics: Used in transformations (translation, scaling, rotation) and rendering pipelines, where matrices represent geometric objects and camera views.
• Image Processing: Applied in filters, image blending, and transformations, where images are often represented as matrices of pixel values.
• Physics Simulations: Essential for solving systems of linear equations, modeling particle interactions, and analyzing data in computational physics.
• Machine Learning: Employed in neural networks for weight updates, gradient calculations, and various other linear algebra operations.
• Engineering: Used in structural analysis, circuit analysis, and control systems, where matrices describe system behaviors.

Solution Approaches

For adding two matrices using C++ classes, the most robust and object-oriented approach involves defining a Matrix class that encapsulates matrix data and operations. This approach allows for cleaner code, better maintainability, and reusability.

Approach: Designing a Matrix Class with Operator Overloading

This approach defines a Matrix class to manage matrix dimensions, data storage, input, output, and addition. Operator overloading is used to define the + operator for Matrix objects, making the addition operation intuitive.

One-line summary: Create a Matrix class to represent matrices, handle dynamic memory, and overload the + operator for seamless addition.

// Matrix Addition using Class
#include <iostream>

using namespace std;

class Matrix {
private:
    int rows;
    int cols;
    int** data; // Pointer to a pointer for 2D array

public:
    // Constructor
    Matrix(int r, int c) : rows(r), cols(c) {
        // Step 1: Allocate memory for rows
        data = new int*[rows];
        // Step 2: Allocate memory for columns for each row
        for (int i = 0; i < rows; ++i) {
            data[i] = new int[cols];
        }
    }

    // Destructor to free allocated memory
    ~Matrix() {
        // Step 1: Free memory for columns in each row
        for (int i = 0; i < rows; ++i) {
            delete[] data[i];
        }
        // Step 2: Free memory for rows
        delete[] data;
    }

    // Method to input matrix elements
    void inputMatrix() {
        cout << "Enter matrix elements (" << rows << "x" << cols << "):" << endl;
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                cout << "Enter element at (" << i + 1 << "," << j + 1 << "): ";
                cin >> data[i][j];
            }
        }
    }

    // Method to display matrix elements
    void displayMatrix() const { // const to indicate it doesn't modify the object
        cout << "Matrix (" << rows << "x" << cols << "):" << endl;
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                cout << data[i][j] << "\\t";
            }
            cout << endl;
        }
    }

    // Overload the + operator for matrix addition
    Matrix operator+(const Matrix& other) const {
        // Step 1: Check if matrices have compatible dimensions for addition
        if (rows != other.rows || cols != other.cols) {
            cout << "Error: Matrices must have the same dimensions for addition." << endl;
            // Return a default matrix or throw an exception
            return Matrix(0, 0); // Returning an empty matrix as an error indication
        }

        // Step 2: Create a new matrix to store the result
        Matrix result(rows, cols);

        // Step 3: Perform element-wise addition
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                result.data[i][j] = this->data[i][j] + other.data[i][j];
            }
        }
        return result;
    }

    // Optional: Getter methods for dimensions if needed externally
    int getRows() const { return rows; }
    int getCols() const { return cols; }
};

int main() {
    int r1, c1, r2, c2;

    // Step 1: Get dimensions for the first matrix
    cout << "Enter dimensions for Matrix 1 (rows columns): ";
    cin >> r1 >> c1;
    Matrix mat1(r1, c1);
    mat1.inputMatrix();

    // Step 2: Get dimensions for the second matrix
    cout << "\\nEnter dimensions for Matrix 2 (rows columns): ";
    cin >> r2 >> c2;
    Matrix mat2(r2, c2);
    mat2.inputMatrix();

    // Step 3: Display original matrices
    cout << "\\n--- Matrices Entered ---" << endl;
    mat1.displayMatrix();
    mat2.displayMatrix();

    // Step 4: Perform matrix addition using overloaded operator
    // Only perform addition if dimensions match for the current example setup
    // (Error handling for dimension mismatch is inside operator+ and returns (0,0) matrix)
    if (r1 == r2 && c1 == c2) {
        Matrix matSum = mat1 + mat2; // Calls the overloaded operator+
        cout << "\\n--- Resultant Matrix (Sum) ---" << endl;
        matSum.displayMatrix();
    } else {
        cout << "\\nCannot add matrices: Dimensions mismatch." << endl;
    }
    
    return 0;
}

Run

Sample Output:

Enter dimensions for Matrix 1 (rows columns): 2 2
Enter matrix elements (2x2):
Enter element at (1,1): 1
Enter element at (1,2): 2
Enter element at (2,1): 3
Enter element at (2,2): 4

Enter dimensions for Matrix 2 (rows columns): 2 2
Enter matrix elements (2x2):
Enter element at (1,1): 5
Enter element at (1,2): 6
Enter element at (2,1): 7
Enter element at (2,2): 8

--- Matrices Entered ---
Matrix (2x2):
1       2       
3       4       
Matrix (2x2):
5       6       
7       8       

--- Resultant Matrix (Sum) ---
Matrix (2x2):
6       8       
10      12

Stepwise Explanation:

1. Matrix Class Definition:

• Private Members: rows, cols (integers for dimensions), and int data (a pointer to an array of pointers, forming a 2D array structure to store matrix elements dynamically).
• Constructor (Matrix(int r, int c)): Initializes rows and cols with provided arguments. It then dynamically allocates memory for the 2D array data. First, memory for rows pointers is allocated, and then for each row, memory for cols integers is allocated.
• Destructor (~Matrix()): Crucial for dynamic memory management. It iterates through each row, freeing the memory allocated for columns (delete[] data[i]), and then frees the memory allocated for the row pointers themselves (delete[] data). This prevents memory leaks.
• inputMatrix() Method: Prompts the user to enter elements for the matrix, populating the data array.
• displayMatrix() Method: Prints the matrix elements to the console in a readable format. The const keyword indicates that this method does not modify the object's state.
• operator+(const Matrix& other) const Method:** This is the overloaded addition operator.
• It first checks if the rows and cols of the current matrix (this) are compatible with the other matrix. If not, it prints an error and returns an empty Matrix (or could throw an exception for more robust error handling).
• If dimensions match, it creates a new Matrix object result with the same dimensions.
• It then iterates through both matrices, adding corresponding elements (this->data[i][j] + other.data[i][j]) and storing the sum in result.data[i][j].
• Finally, it returns the result matrix.

1. main() Function:

• Get Dimensions: Prompts the user to enter the dimensions (rows and columns) for two matrices.
• Create Matrix Objects: Matrix mat1(r1, c1) and Matrix mat2(r2, c2) create instances of the Matrix class, which in turn dynamically allocate memory for their respective matrices.
• Input Elements: mat1.inputMatrix() and mat2.inputMatrix() call the input methods to populate the matrices.
• Display Original: mat1.displayMatrix() and mat2.displayMatrix() show the user the entered matrices.
• Perform Addition:
• An if condition checks if the dimensions match before attempting addition to prevent runtime errors (though the operator+ also handles this).
• Matrix matSum = mat1 + mat2; demonstrates the clean syntax enabled by operator overloading. This line internally calls mat1.operator+(mat2).
• Display Result: matSum.displayMatrix() prints the matrix obtained from the addition.
• Automatic Memory Deallocation: When mat1, mat2, and matSum go out of scope at the end of main, their respective destructors are automatically called, freeing the dynamically allocated memory.

Conclusion

By encapsulating matrix data and operations within a Matrix class, we achieve a clean, modular, and extensible solution for matrix addition in C++. The use of operator overloading makes the addition syntax intuitive and similar to primitive data types. This approach also demonstrates crucial C++ concepts like dynamic memory management with constructors and destructors, ensuring proper resource handling.

Summary

• Matrix addition requires matrices of identical dimensions.
• A Matrix class encapsulates matrix data (rows, columns, elements) and operations.
• Dynamic memory allocation (new and delete) is used within the class to manage 2D array storage.
• A destructor (~Matrix()) is essential to prevent memory leaks by freeing allocated memory.
• Operator overloading (operator+) allows for an intuitive syntax (matrix1 + matrix2) for matrix addition.
• Error handling for dimension mismatch is crucial in the addition operation.