C++ Program To Add Two Matrices Using 2d Array

In many computational tasks, the ability to perform basic mathematical operations on data structures like matrices is fundamental. Matrix addition is a common operation used across various fields, enabling the combination of data sets represented in tabular form.

In this article, you will learn how to implement a C++ program to add two matrices using 2D arrays, understanding the underlying logic and practical application.

Problem Statement

The problem involves taking two matrices of the same dimensions, typically represented as 2D arrays, and producing a third matrix where each element is the sum of the corresponding elements from the input matrices. This operation assumes that both input matrices have an identical number of rows and columns.

For example, if you have two 2x2 matrices, Matrix A and Matrix B:

Matrix A         Matrix B
[[1, 2],         [[5, 6],
 [3, 4]]          [7, 8]]

The resulting Matrix C after addition would be:

Matrix C
[[1+5, 2+6],
 [3+7, 4+8]]

[[6,  8],
 [10, 12]]

Example

Let's consider two 3x3 matrices.

Input Matrix 1:

1 2 3
4 5 6
7 8 9

Input Matrix 2:

9 8 7
6 5 4
3 2 1

The expected output after adding these two matrices will be:

10 10 10
10 10 10
10 10 10

Background & Knowledge Prerequisites

To effectively understand and implement the solution, a basic understanding of the following C++ concepts is helpful:

• Variables and Data Types: Declaring integers and arrays.
• Arrays: How to declare and access elements in one-dimensional and two-dimensional arrays.
• Loops: Especially for loops for iterating through array elements.
• Input/Output Operations: Using cin for input and cout for output.

Use Cases or Case Studies

Matrix addition is a foundational operation with diverse applications:

• Image Processing: In graphics, images can be represented as matrices where pixel values are elements. Adding matrices can be used for blending images or applying filters.
• Computer Graphics: Used in transformations, such as combining multiple translation or rotation effects on objects in a 3D space.
• Physics and Engineering: Solving systems of linear equations, representing forces, stresses, or analyzing electrical circuits.
• Machine Learning and Data Science: Fundamental in many algorithms, including neural networks (e.g., combining weight matrices or feature matrices).
• Game Development: Calculating object positions, velocities, or applying cumulative effects in game physics.

Solution Approaches

For adding two matrices using 2D arrays, the most direct and common approach involves iterating through corresponding elements of both matrices and storing their sum in a new matrix.

Direct Matrix Addition using 2D Arrays

This approach declares three 2D arrays: two for the input matrices and one for the result. It then uses nested loops to traverse each element, performs the addition, and stores the result.

One-line summary

Iterate through the rows and columns of both matrices, adding corresponding elements and storing the sum in a third result matrix.

Code example

// Matrix Addition using 2D Arrays
#include <iostream>
using namespace std;

int main() {
    // Define matrix dimensions
    const int ROWS = 3;
    const int COLS = 3;

    // Declare two input matrices and one result matrix
    int matrix1[ROWS][COLS];
    int matrix2[ROWS][COLS];
    int sumMatrix[ROWS][COLS];

    // Step 1: Input elements for the first matrix
    cout << "Enter elements for Matrix 1 (" << ROWS << "x" << COLS << "):" << endl;
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            cout << "Enter element matrix1[" << i << "][" << j << "]: ";
            cin >> matrix1[i][j];
        }
    }

    // Step 2: Input elements for the second matrix
    cout << "\\nEnter elements for Matrix 2 (" << ROWS << "x" << COLS << "):" << endl;
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            cout << "Enter element matrix2[" << i << "][" << j << "]: ";
            cin >> matrix2[i][j];
        }
    }

    // Step 3: Add corresponding elements of matrix1 and matrix2
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            sumMatrix[i][j] = matrix1[i][j] + matrix2[i][j];
        }
    }

    // Step 4: Display the sumMatrix
    cout << "\\nSum of the two matrices is:" << endl;
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            cout << sumMatrix[i][j] << " ";
        }
        cout << endl; // Move to the next row after printing all elements in the current row
    }

    return 0;
}

Run

Sample output

Using the example matrices from the "Problem Statement" and "Example" sections:

Enter elements for Matrix 1 (3x3):
Enter element matrix1[0][0]: 1
Enter element matrix1[0][1]: 2
Enter element matrix1[0][2]: 3
Enter element matrix1[1][0]: 4
Enter element matrix1[1][1]: 5
Enter element matrix1[1][2]: 6
Enter element matrix1[2][0]: 7
Enter element matrix1[2][1]: 8
Enter element matrix1[2][2]: 9

Enter elements for Matrix 2 (3x3):
Enter element matrix2[0][0]: 9
Enter element matrix2[0][1]: 8
Enter element matrix2[0][2]: 7
Enter element matrix2[1][0]: 6
Enter element matrix2[1][1]: 5
Enter element matrix2[1][2]: 4
Enter element matrix2[2][0]: 3
Enter element matrix2[2][1]: 2
Enter element matrix2[2][2]: 1

Sum of the two matrices is:
10 10 10 
10 10 10 
10 10 10

Stepwise explanation

1. Define Dimensions: const int ROWS = 3; and const int COLS = 3; define the size of the matrices. Using const makes these values fixed and improves readability.
2. Declare Arrays: Three 2D arrays (matrix1, matrix2, sumMatrix) are declared. Each can hold ROWS * COLS integer elements.
3. Input Matrix 1: A nested for loop iterates ROWS times (outer loop for rows) and COLS times (inner loop for columns) to prompt the user to enter elements for matrix1. cin reads each element into its respective position matrix1[i][j].
4. Input Matrix 2: Similar to Step 3, elements for matrix2 are taken from the user.
5. Perform Addition: Another set of nested for loops iterates through both matrices. In each iteration, sumMatrix[i][j] is calculated as the sum of matrix1[i][j] and matrix2[i][j].
6. Display Result: The final nested for loop prints the elements of sumMatrix. cout << sumMatrix[i][j] << " "; prints the element followed by a space. cout << endl; is used after each row to move to the next line, ensuring the output matrix is formatted correctly.

Conclusion

Adding two matrices using 2D arrays in C++ is a straightforward process that leverages nested loops to access and manipulate individual elements. This fundamental operation is crucial for understanding more complex matrix manipulations and their wide array of applications in various technical and scientific fields.

Summary

• Matrix addition requires two matrices of identical dimensions.
• The result is a new matrix where each element is the sum of corresponding elements from the input matrices.
• C++ implementation uses 2D arrays to represent matrices.
• Nested for loops are essential for iterating through rows and columns to perform element-wise addition.
• This operation is foundational in image processing, computer graphics, engineering, and machine learning.