Key Programs For Addition of Two Matrix in C

Published: 18 Feb 2025 | Reading Time: 4 min read

Overview

Matrix addition is a fundamental operation in linear algebra, widely used in various fields such as computer graphics, machine learning, and scientific computing. Matrices are rectangular arrays of numbers arranged in rows and columns, powerful tools for representing and manipulating data in multiple dimensions. The addition of two matrix program in C involves combining two matrices of the same dimensions by adding their corresponding elements.

This article explores how to use different methods to add two matrices using the C programming language, providing detailed explanations of algorithms, implementations, and examples.

---

Table of Contents

• What are Matrices?
• C Program for Addition of Two Matrix
• Flowchart for Matrix Addition
• Implementation of Addition Matrix in C
• Addition of Two Matrices in C Using Functions
• C Program to Add Two Matrices Using Dynamic Memory Allocation
• Conclusion
• Frequently Asked Questions

---

What are Matrices?

A matrix is a rectangular array of numbers arranged in rows and columns. In C, matrices are represented as two-dimensional arrays. For matrix addition to be valid, both matrices must have the same dimensions (i.e., the same number of rows and columns).

Matrix Addition Notation

Given two matrices A and B, both of size m×n, the matrix sum A+B is a matrix of the same size, with each element obtained by adding the corresponding elements from matrices A and B.

A+B=[aij+bij]mxn

Where:

• aij and bij are the elements of matrices A and B at the i-th row and j-th column respectively
• m is the number of rows
• n is the number of columns in both matrices A and B

Arrays in C

In C programming, matrices are implemented using arrays. A matrix can be represented as a 2D array, where each element is accessed using row and column indices.

Example Declaration

int A[100][100]; // For a matrix A with 100 rows and 100 columns

Accessing Elements

A[i][j] // Accesses the element at the i-th row and j-th column

Multidimensional Arrays in C

A multidimensional array in C is essentially an array of arrays. For matrix representation, the most common multidimensional array is a 2D array, which is used to store rows and columns of a matrix.

Example of a 2D Array

int matrix[3][3]; // A 3x3 matrix

Storing and Accessing Elements

matrix[0][0] = 1;  // First row, first column
matrix[2][2] = 5;  // Third row, third column

Matrix Addition Process

int A[100][100], B[100][100], sum[100][100];
for (i = 0; i < m; ++i) {
    for (j = 0; j < n; ++j) {
        sum[i][j] = A[i][j] + B[i][j]; // Element-wise addition
    }
}

Array of Structure in C

An array of structures in C is an array where each element is a structure. In the context of matrices, this could be used to store matrices in a more complex way, if you want to add extra metadata or properties to each matrix element.

Example Structure

struct MatrixElement {
    int value;
    char label[10];
};

Declaration

struct MatrixElement A[100][100];  // 2D array of structure

Assigning Values

A[0][0].value = 1;  // Set value of the first element
strcpy(A[0][0].label, "first");  // Assign a label to the first element

Matrix Addition with Structures

struct MatrixElement sum[100][100];
for (i = 0; i < m; ++i) {
    for (j = 0; j < n; ++j) {
        sum[i][j].value = A[i][j].value + B[i][j].value;
    }
}

What is Matrix Addition?

Matrix addition is defined as the process of adding two matrix elements. Two matrices, A and B, must have the same number of rows and columns to be added. The resulting matrix C will also have the same dimensions, where each element is calculated as follows:

Cij = Aij + Bij

This operation is similar to adding algebraic expressions, where only like terms can be combined. In the case of matrices, only corresponding elements from the two matrices can be added together.

Conditions for Matrix Addition

• Both matrices must have the same number of rows
• Both matrices must have the same number of columns

Properties of Matrix Addition

1. Commutative Property

Adding in any order does not affect the result. If A and B are matrices of the same dimensions, then:

A+B=B+A

This means that you can add matrices in any order, and the sum will remain the same.

2. Associative Property

The way in which matrices are grouped during addition does not affect the result. If A, B, and C are matrices of the same dimensions, then:

(A+B)+C=A+(B+C)

This allows for flexibility in how calculations are performed when adding multiple matrices.

3. Additive Identity

An additive identity, known as the zero matrix, results in the original matrix A when added to any matrix A. The zero matrix has all its elements equal to zero:

A+0=A

This property ensures that adding a zero matrix does not change the value of the original matrix.

4. Additive Inverse

For every matrix A, there exists an additive inverse (denoted as −A) such that:

A+(−A)=0

Here, −A is the matrix where each element is the negation of the corresponding element in A. This property allows for the cancellation of matrices.

5. Compatibility with Scalar Multiplication Distributive Property

When a matrix is multiplied by a scalar, the result can still be added to another matrix of the same dimension. If k is a scalar and A and B are matrices, then:

k(A+B)=kA+kB

This property shows how scalar multiplication interacts with matrix addition.

---

How to Create a Matrix in C Language

1. Matrix Using an Array

In C, a matrix can be represented as a 2D array (array of arrays).

Code Example

#include <stdio.h>

int main() {
    // Define a 3x3 matrix using an array
    int matrix[3][3] = {
        {5, 10, 15},
        {20, 25, 30},
        {35, 40, 45}
    };

    // Print the matrix
    printf("Matrix created using an array:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Explanation

• The matrix is defined as a two-dimensional array with three rows and three columns, initialised with specific values
• Nested loops iterate through each row (i) and column (j) of the matrix to print its elements
• Each row is printed on a new line
• The output displays the matrix in a structured format

Output

Matrix created using an array:
5 10 15
20 25 30
35 40 45

2. Matrix Using a Nested Loop

This approach uses nested loops to initialize and print a 3x3 matrix.

Code Example

#include <stdio.h>

int main() {
    int matrix[3][3];

    // Initialize the matrix elements using nested loops
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            matrix[i][j] = (i + 1) * (j + 1); // Example initialization
        }
    }

    // Print the matrix
    printf("Matrix created using a nested loop:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Explanation

• The two-dimensional array matrix is declared
• Nested loops are used to fill the matrix
• Each element is calculated based on its row and column indices, specifically (i + 1) * (j + 1), resulting in a multiplication table format
• The nested loops print each element of the matrix

Output

Matrix created using a nested loop:
1 2 3
2 4 6
3 6 9

3. Matrix Using Dynamic Memory Allocation

Code Example

#include <stdio.h>
#include <stdlib.h>

int main() {
    int rows = 3, cols = 3;

    // Dynamic memory allocation for a matrix
    int **matrix = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++)
        matrix[i] = (int *)malloc(cols * sizeof(int));

    // Initialize the matrix elements
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = (i + j) * (i - j); // Example initialization
        }
    }

    // Print the matrix
    printf("Matrix created using dynamic memory allocation:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // Free allocated memory
    for (int i = 0; i < rows; i++)
        free(matrix[i]);
    free(matrix);

    return 0;
}

Explanation

• Memory for a two-dimensional array is allocated at runtime using malloc
• An array of pointers (matrix) is created first, followed by allocating memory for each row
• Elements are initialised based on the formula (i + j) * (i - j), which produces varying values depending on the indices
• The nested loops print each element of the dynamically allocated matrix
• After usage, free() is called to deallocate memory for each row and then for the main pointer to prevent memory leaks

Output

Matrix created using dynamic memory allocation:
0 -1 -2
1 0 -1
2 -1 0

---

C Program for Addition of Two Matrix

Basic Implementation

Code

#include <stdio.h>

int main() {
    int rows, cols;
    scanf("%d %d", &rows, &cols);

    int A[rows][cols], B[rows][cols], C[rows][cols];

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &A[i][j]);
        }
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &B[i][j]);
        }
    }

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            C[i][j] = A[i][j] + B[i][j];
            printf("%d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Explanation

• The program uses two 2D arrays, A and B, to store the elements of the two input matrices
• The resulting matrix is stored in C
• The user is prompted to input the number of rows (rows) and columns (cols), followed by the elements of both matrices
• The program adds the two matrices element by element and stores the result in the result matrix

Input/Output Example

Input:

2 3
1 2 3
4 5 6
7 8 9
10 11 12

Output:

8 10 12
14 16 18

C Program to Add Two Square Matrices

This program demonstrates how to add two square matrices. A square matrix has an equal number of rows and columns.

Code

#include <stdio.h>

int main() {
    int n;
    printf("Enter the size of the square matrix: ");
    scanf("%d", &n);

    int A[n][n], B[n][n], C[n][n];

    // Input elements of first square matrix
    printf("Enter elements of Matrix A:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &A[i][j]);
        }
    }

    // Input elements of second square matrix
    printf("Enter elements of Matrix B:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &B[i][j]);
        }
    }

    // Adding matrices A and B, storing result in C
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            C[i][j] = A[i][j] + B[i][j];
        }
    }

    // Output the resultant matrix
    printf("Resulting Matrix (A + B):\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Explanation

• The user inputs the size n for the square matrices A and B
• The program adds corresponding elements from A and B and stores the result in matrix C
• The resultant matrix is displayed after the addition

Output Example

Enter the size of the square matrix: 2
Enter elements of Matrix A:
1 2
3 4
Enter elements of Matrix B:
5 6
7 8

C Program to Add Two Rectangular Matrices

This program adds two rectangular matrices where the number of rows and columns can vary. It ensures that both matrices have the same dimensions before performing the addition.

Code

#include <stdio.h>

int main() {
    int r, c;
    printf("Enter the number of rows and columns for the matrices: ");
    scanf("%d %d", &r, &c);

    int A[r][c], B[r][c], C[r][c];

    // Input elements of the first rectangular matrix
    printf("Enter elements of Matrix A:\n");
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            scanf("%d", &A[i][j]);
        }
    }

    // Input elements of the second rectangular matrix
    printf("Enter elements of Matrix B:\n");
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            scanf("%d", &B[i][j]);
        }
    }

    // Adding matrices A and B, storing result in C
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            C[i][j] = A[i][j] + B[i][j];
        }
    }

    // Output the resultant matrix
    printf("Resulting Matrix (A + B):\n");
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            printf("%d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Explanation

• The user inputs the number of rows (r) and columns (c) for the rectangular matrices A and B
• Similar to the square matrix program, corresponding elements from A and B are added and stored in matrix C
• The resulting matrix is printed

Output Example

Enter the number of rows and columns for the matrices: 2 3
Enter elements of Matrix A:
1 2 3
4 5 6
Enter elements of Matrix B:
7 8 9
10 11 12

---

Algorithm for Matrix Addition

Step-by-Step Algorithm

1. Enter the number of rows and columns for both matrices. Ensure they have the same dimensions.
2. Declare two matrices for input and one matrix to store the result of the addition.
3. Use nested loops to read elements for both matrices from the user.
4. Use nested loops to iterate through each element of both matrices.
5. Add corresponding elements and store the result in the resulting matrix.
6. Print the resulting matrix containing both input matrices' corresponding elements' sums.

---

Flowchart for Matrix Addition

[Flowchart image showing the matrix addition process]

---

Implementation of Addition Matrix in C

Detailed Implementation

Code

#include <stdio.h>

int main() {
    int r, c;
    int mat1[100][100], mat2[100][100], sum[100][100];

    // Input dimensions
    printf("Enter number of rows: ");
    scanf("%d", &r);
    printf("Enter number of columns: ");
    scanf("%d", &c);

    // Input first matrix
    printf("Enter elements of Matrix 1:\n");
    for (int i = 0; i < r; ++i) {
        for (int j = 0; j < c; ++j) {
            printf("Element [%d][%d]: ", i, j);
            scanf("%d", &mat1[i][j]);
        }
    }

    // Input second matrix
    printf("Enter elements of Matrix 2:\n");
    for (int i = 0; i < r; ++i) {
        for (int j = 0; j < c; ++j) {
            printf("Element [%d][%d]: ", i, j);
            scanf("%d", &mat2[i][j]);
        }
    }

    // Adding matrices
    for (int i = 0; i < r; ++i) {
        for (int j = 0; j < c; ++j) {
            sum[i][j] = mat1[i][j] + mat2[i][j];
        }
    }

    // Output result
    printf("Sum of the two matrices:\n");
    for (int i = 0; i < r; ++i) {
        for (int j = 0; j < c; ++j) {
            printf("%d ", sum[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Input Example

Number of rows: 3
Number of columns: 3
Matrix 1:
0 1 2
3 4 5
6 7 8

Matrix 2:
9 10 11
12 13 14
15 16 17

Output Example

The sum of the two matrices:
9 11 13
15 17 19
21 23 25

Explanation

• The program starts by declaring variables for row and column counts and creating three matrices (mat1, mat2, and sum)
• Input the number of rows and columns, followed by the elements of both matrices
• Nested loops iterate through each element, adding corresponding elements from mat1 and mat2, storing the result in sum
• Finally, the resulting matrix is printed to the console

Complexity Analysis

• Time Complexity: O(n²)
• Space Complexity: O(n²)

---

Addition of Two Matrices in C Using Functions

Implementation with Functions

Code

#include <stdio.h>

void addMatrices(int rows, int cols, int A[rows][cols], int B[rows][cols], int result[rows][cols]) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            result[i][j] = A[i][j] + B[i][j];
        }
    }
}

int main() {
    int rows, cols;

    // Input number of rows and columns
    printf("Enter number of rows and columns: ");
    scanf("%d %d", &rows, &cols);

    int A[rows][cols], B[rows][cols], result[rows][cols];

    // Input elements of first matrix
    printf("Enter elements of Matrix A:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &A[i][j]);
        }
    }

    // Input elements of second matrix
    printf("Enter elements of Matrix B:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &B[i][j]);
        }
    }

    // Call the function to add matrices
    addMatrices(rows, cols, A, B, result);

    // Output the result
    printf("Resulting Matrix (A + B):\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Explanation

• The function addMatrices() takes the dimensions of the matrices (rows and cols), two matrices A and B, and a result matrix to store the sum of A and B
• In the main() function, the user inputs the matrices A and B, and the addition result is displayed using the addMatrices() function

Output Example

Enter number of rows and columns: 2 3
Enter elements of Matrix A:
1 2 3
4 5 6
Enter elements of Matrix B:
7 8 9
10 11 12
Resulting Matrix (A + B):
8 10 12
14 16 18

Complexity Analysis

• Time Complexity: O(rows×cols)
• Space Complexity: O(rows×cols)

---

C Program to Add Two Matrices Using Dynamic Memory Allocation

This program demonstrates matrix addition using dynamic memory allocation with malloc() for creating matrices.

Code

#include <stdio.h>
#include <stdlib.h>

void addMatrices(int rows, int cols, int **A, int **B, int **result) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            result[i][j] = A[i][j] + B[i][j];
        }
    }
}

int main() {
    int rows, cols;

    // Input number of rows and columns
    printf("Enter number of rows and columns: ");
    scanf("%d %d", &rows, &cols);

    // Dynamic memory allocation for matrices
    int **A = (int **)malloc(rows * sizeof(int *));
    int **B = (int **)malloc(rows * sizeof(int *));
    int **result = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        A[i] = (int *)malloc(cols * sizeof(int));
        B[i] = (int *)malloc(cols * sizeof(int));
        result[i] = (int *)malloc(cols * sizeof(int));
    }

    // Input elements of first matrix
    printf("Enter elements of Matrix A:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &A[i][j]);
        }
    }

    // Input elements of second matrix
    printf("Enter elements of Matrix B:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &B[i][j]);
        }
    }

    // Call the function to add matrices
    addMatrices(rows, cols, A, B, result);

    // Output the result
    printf("Resulting Matrix (A + B):\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }

    // Free dynamically allocated memory
    for (int i = 0; i < rows; i++) {
        free(A[i]);
        free(B[i]);
        free(result[i]);
    }
    free(A);
    free(B);
    free(result);

    return 0;
}

Explanation

• In this program, matrices A, B, and result are dynamically allocated using malloc()
• This allows the program to handle matrices of any size, even if the size is not known at compile time
• The addMatrices() function is the same as in the previous example, but this time it works with dynamically allocated memory
• After the computation, the allocated memory is freed using free() to avoid memory leaks

Output Example

Enter number of rows and columns: 2 3
Enter elements of Matrix A:
1 2 3
4 5 6
Enter elements of Matrix B:
7 8 9
10 11 12

Resulting Matrix (A + B):
8 10 12
14 16 18

Complexity Analysis

• Time Complexity: O(rows×cols)
• Space Complexity: O(rows×cols)

---

Conclusion

In conclusion, understanding how to add two matrices in C enhances programming skills and provides insight into more complex mathematical operations. It explores advanced topics such as matrix multiplication and determinants. By mastering matrix addition, programmers can effectively handle multi-dimensional data structures and apply mathematical concepts to real-world problems.

---

Frequently Asked Questions

What basic operations can be performed on matrices in C?

The basic operations include addition, subtraction, multiplication, and finding the transpose of a matrix. Each operation typically involves nested loops to iterate through the elements.

Can I use dynamic memory allocation for matrices?

Dynamic memory allocation is commonly used to create matrices of variable sizes. You can allocate memory using malloc and ensure to free it after use to avoid memory leaks:

free(matrix[i]); // Free each row
free(matrix); // Free the main pointer

What are the basic operations that can be performed on matrices?

The basic operations include:

• Addition: Combining two matrices by adding corresponding elements
• Subtraction: Similar to addition but involves subtracting corresponding elements
• Multiplication: Combining two matrices to produce a third matrix, following specific rules for element multiplication and summation
• Transpose: Flipping a matrix over its diagonal, switching the row and column indices

---

Related Articles

• Complete Guide on String Functions in C
• Mastering Insertion Sort in C: Code, Logic, and Applications
• Quick Sort Algorithm Explained: Steps, Code Examples and Use Cases
• Switch Statement in C: Syntax, Flowchart & Sample Programs
• The Ultimate Guide to Binary Search Algorithm in C
• Merge Sort in C: A Step-by-Step Guide with Code Examples

---

Source: NxtWave (CCBP.in)

Original URL: https://www.ccbp.in/blog/articles/addition-of-two-matrix-in-c