C Program To Add Two Matrix Using Pointers

Adding two matrices is a fundamental operation in linear algebra with various applications. When working with C, using pointers can provide a flexible and efficient way to handle matrix operations, especially for dynamically sized matrices.

In this article, you will learn how to add two matrices in C using pointers for dynamic memory allocation and element access, providing a robust solution for various matrix sizes.

Problem Statement

The problem is to compute the sum of two matrices, A and B, to produce a third matrix, C. For matrix addition, both input matrices must have the same dimensions (number of rows and columns). Each element $C_{ij}$ in the resulting matrix is the sum of the corresponding elements $A_{ij}$ and $B_{ij}$ from the input matrices. Implementing this with pointers in C requires careful memory management and element referencing.

Example

Consider two 2x2 matrices:

Matrix A:

1 2
3 4

Matrix B:

5 6
7 8

The expected output matrix C (A + B) would be:

6 8
10 12

Background & Knowledge Prerequisites

To understand this article, readers should be familiar with:

• C Language Basics: Variables, data types, loops (for, while), conditional statements (if-else).
• Arrays in C: One-dimensional and multi-dimensional arrays.
• Pointers in C: Declaring, initializing, dereferencing pointers, and pointer arithmetic.
• Dynamic Memory Allocation: malloc(), calloc(), free() functions from .

Relevant imports for this program include for input/output operations and for dynamic memory allocation.

Use Cases or Case Studies

Matrix addition, often implemented using pointers for efficiency, finds applications in various fields:

• Image Processing: Images can be represented as matrices, where pixels are elements. Operations like blending two images or adding visual effects often involve matrix addition.
• Computer Graphics: Transformations (translation, scaling, rotation) in 3D graphics are performed using matrices. Combining transformations can involve matrix addition.
• Physics and Engineering: Solving systems of linear equations, analyzing structural loads, or simulating physical systems often uses matrix operations.
• Machine Learning: Many algorithms, especially in neural networks, involve extensive matrix operations, including addition, often optimized for performance using pointer-based implementations.
• Data Analysis: Combining datasets or performing statistical analyses can sometimes be modeled as matrix operations, where elements represent data points.

Solution Approaches

We will focus on a robust approach using pointers for dynamic memory allocation to represent matrices and then perform addition. This method offers flexibility as matrix dimensions are not fixed at compile time.

Approach: Dynamic Matrix Allocation and Addition with Pointers

This approach involves dynamically allocating memory for matrices using malloc and then accessing and adding their elements using pointer arithmetic.

One-line summary: Dynamically allocate 2D matrices using int** pointers, read elements, perform element-wise addition in a function, and print the resulting matrix, ensuring proper memory deallocation.

Code Example:

// Matrix Addition Using Pointers
#include <stdio.h>
#include <stdlib.h> // For malloc and free

// Function to dynamically allocate a matrix
int** allocateMatrix(int rows, int cols) {
    int** matrix = (int**)malloc(rows * sizeof(int*));
    if (matrix == NULL) {
        perror("Memory allocation failed for rows");
        exit(EXIT_FAILURE);
    }
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
        if (matrix[i] == NULL) {
            perror("Memory allocation failed for columns");
            // Free previously allocated rows before exiting
            for (int j = 0; j < i; j++) {
                free(matrix[j]);
            }
            free(matrix);
            exit(EXIT_FAILURE);
        }
    }
    return matrix;
}

// Function to read elements into a matrix
void readMatrix(int** matrix, int rows, int cols) {
    printf("Enter elements:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("Enter element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }
}

// Function to add two matrices using pointers
void addMatrices(int** mat1, int** mat2, int** result, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            // Accessing elements using array-like indexing on pointers
            result[i][j] = mat1[i][j] + mat2[i][j];
            // Alternative using pointer arithmetic:
            // *(*(result + i) + j) = *(*(mat1 + i) + j) + *(*(mat2 + i) + j);
        }
    }
}

// Function to print a matrix
void printMatrix(int** matrix, int rows, int cols) {
    printf("Matrix:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d\\t", matrix[i][j]);
        }
        printf("\\n");
    }
}

// Function to free dynamically allocated matrix memory
void freeMatrix(int** matrix, int rows) {
    if (matrix == NULL) return;
    for (int i = 0; i < rows; i++) {
        free(matrix[i]); // Free each row
    }
    free(matrix); // Free the array of row pointers
}

int main() {
    int rows, cols;

    // Step 1: Get dimensions from the user
    printf("Enter number of rows: ");
    scanf("%d", &rows);
    printf("Enter number of columns: ");
    scanf("%d", &cols);

    // Step 2: Dynamically allocate memory for the two input matrices and the result matrix
    int** matrixA = allocateMatrix(rows, cols);
    int** matrixB = allocateMatrix(rows, cols);
    int** resultMatrix = allocateMatrix(rows, cols);

    // Step 3: Read elements for Matrix A
    printf("\\n--- For Matrix A ---\\n");
    readMatrix(matrixA, rows, cols);

    // Step 4: Read elements for Matrix B
    printf("\\n--- For Matrix B ---\\n");
    readMatrix(matrixB, rows, cols);

    // Step 5: Add the two matrices
    addMatrices(matrixA, matrixB, resultMatrix, rows, cols);

    // Step 6: Print the matrices and their sum
    printf("\\n--- Matrix A ---\\n");
    printMatrix(matrixA, rows, cols);

    printf("\\n--- Matrix B ---\\n");
    printMatrix(matrixB, rows, cols);

    printf("\\n--- Sum Matrix (A + B) ---\\n");
    printMatrix(resultMatrix, rows, cols);

    // Step 7: Free dynamically allocated memory
    freeMatrix(matrixA, rows);
    freeMatrix(matrixB, rows);
    freeMatrix(resultMatrix, rows);

    return 0;
}

Run

Sample Output:

Enter number of rows: 2
Enter number of columns: 2

--- For Matrix A ---
Enter elements:
Enter element [0][0]: 1
Enter element [0][1]: 2
Enter element [1][0]: 3
Enter element [1][1]: 4

--- For Matrix B ---
Enter elements:
Enter element [0][0]: 5
Enter element [0][1]: 6
Enter element [1][0]: 7
Enter element [1][1]: 8

--- Matrix A ---
Matrix:
1       2
3       4

--- Matrix B ---
Matrix:
5       6
7       8

--- Sum Matrix (A + B) ---
Matrix:
6       8
10      12

Stepwise Explanation:

1. allocateMatrix(int rows, int cols) Function:
   • This function allocates memory for a 2D integer array (matrix).

It first allocates an array of int* pointers, where each pointer will point to a row.

Then, it iterates through this array of pointers, allocating memory for each row (an array of ints).

Error handling is included to check if malloc fails, preventing crashes and gracefully exiting.

It returns a pointer to the array of row pointers (int**).

1. readMatrix(int matrix, int rows, int cols) Function:**
   • Takes the dynamically allocated matrix pointer and its dimensions.

Uses nested for loops to iterate through each element position.

scanf() is used to read an integer from the user and store it at the matrix[i][j] location.

1. addMatrices(int mat1, int mat2, int result, int rows, int cols) Function:**
   • Takes pointers to the two input matrices (mat1, mat2), the result matrix (result), and their dimensions.

Uses nested for loops to traverse all elements.

For each corresponding element at [i][j], it sums mat1[i][j] and mat2[i][j] and stores the result in result[i][j].

The matrix[i][j] syntax is syntactic sugar for pointer dereferencing (e.g., *(*(matrix + i) + j)), making the code more readable while still utilizing pointers.

1. printMatrix(int matrix, int rows, int cols) Function:**
   • Similar to readMatrix, it iterates through the matrix elements.

printf() displays each element, followed by a tab (\t), and a newline (\n) after each row for proper formatting.

1. freeMatrix(int matrix, int rows) Function:**
   • Crucially, this function deallocates the memory that was dynamically allocated by allocateMatrix.

It iterates through each row, calling free() on matrix[i] to release the memory for that specific row.

Finally, it calls free(matrix) to release the memory for the array of row pointers itself. This prevents memory leaks.

1. main() Function:
   • Prompts the user to enter the number of rows and columns.

Calls allocateMatrix three times to create matrixA, matrixB, and resultMatrix.

Calls readMatrix to populate matrixA and matrixB.

Calls addMatrices to perform the addition.

Calls printMatrix to display all three matrices.

Calls freeMatrix three times to release all dynamically allocated memory, ensuring no memory leaks.

Conclusion

Using pointers for matrix operations in C provides a powerful way to handle dynamically sized data structures. By allocating memory dynamically, we gain flexibility and efficiency, particularly when dealing with large matrices whose dimensions are not known until runtime. While the syntax might seem more complex initially, it offers greater control over memory, a fundamental aspect of C programming.

Summary

• Matrix addition requires both matrices to have identical dimensions.
• Pointers in C enable dynamic memory allocation for matrices using malloc and free.
• A common approach for dynamic 2D arrays is int, where an array of pointers points to individual dynamically allocated rows.
• Memory must be explicitly deallocated using free() to prevent memory leaks, freeing each row first, then the array of row pointers.
• Array-like syntax (matrix[i][j]) can still be used with int pointers, which the compiler translates into pointer arithmetic for convenience.