Table of Contents

What is a 2D Array?

A 2D array (two-dimensional array) is an array of arrays. It represents data in a table format with rows and columns, like a matrix or grid.

Declaration Syntax

data_type array_name[rows][columns];

Declaring and Initializing 2D Arrays

1. Declaration Then Assignment

#include <stdio.h>
int main() {
int matrix[3][4];  // 3 rows, 4 columns
// Assign values
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[0][3] = 4;
matrix[1][0] = 5;
matrix[1][1] = 6;
matrix[1][2] = 7;
matrix[1][3] = 8;
matrix[2][0] = 9;
matrix[2][1] = 10;
matrix[2][2] = 11;
matrix[2][3] = 12;
printf("matrix[1][2] = %d\n", matrix[1][2]);  // 7
return 0;
}

2. Initialization at Declaration (Full)

#include <stdio.h>
int main() {
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
printf("matrix[0][0] = %d\n", matrix[0][0]);  // 1
printf("matrix[2][3] = %d\n", matrix[2][3]);  // 12
return 0;
}

3. Omitting Row Size (Auto-Detection)

#include <stdio.h>
int main() {
// Column size MUST be specified
int matrix[][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};  // Compiler auto-detects 3 rows
printf("Number of rows: %lu\n", sizeof(matrix)/sizeof(matrix[0]));  // 3
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
return 0;
}

4. Partial Initialization (Remaining = 0)

#include <stdio.h>
int main() {
int matrix[3][3] = {
{1, 2},     // {1, 2, 0}
{4, 5, 6},  // {4, 5, 6}
{7}         // {7, 0, 0}
};
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) {
printf("%d ", matrix[i][j]);
}
printf("\n");
}
return 0;
}
/* Output:
1 2 0
4 5 6
7 0 0
*/

5. Initialize All to Zero

int matrix[5][5] = {0};  // All 25 elements = 0
int matrix2[3][4] = {};  // All elements = 0 (C99+)

Accessing 2D Array Elements

#include <stdio.h>
int main() {
int matrix[2][3] = {{10, 20, 30}, {40, 50, 60}};
// Access individual elements
printf("matrix[0][0] = %d\n", matrix[0][0]);  // 10 (1st row, 1st col)
printf("matrix[0][2] = %d\n", matrix[0][2]);  // 30 (1st row, 3rd col)
printf("matrix[1][1] = %d\n", matrix[1][1]);  // 50 (2nd row, 2nd col)
printf("matrix[1][2] = %d\n", matrix[1][2]);  // 60 (2nd row, 3rd col)
// Modify elements
matrix[0][1] = 99;
printf("Modified: matrix[0][1] = %d\n", matrix[0][1]);  // 99
return 0;
}

Traversing 2D Arrays (Nested Loops)

Standard Traversal (Row by Row)

#include <stdio.h>
int main() {
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
printf("Matrix (3 rows × 4 columns):\n");
for(int i = 0; i < 3; i++) {           // Outer loop = rows
for(int j = 0; j < 4; j++) {       // Inner loop = columns
printf("%3d ", matrix[i][j]);
}
printf("\n");  // New line after each row
}
return 0;
}

User Input for 2D Array

#include <stdio.h>
int main() {
int rows, cols;
printf("Enter number of rows: ");
scanf("%d", &rows);
printf("Enter number of columns: ");
scanf("%d", &cols);
int matrix[rows][cols];  // Variable Length Array (C99)
// Input
printf("\nEnter elements:\n");
for(int i = 0; i < rows; i++) {
for(int j = 0; j < cols; j++) {
printf("matrix[%d][%d] = ", i, j);
scanf("%d", &matrix[i][j]);
}
}
// Output
printf("\nYour matrix:\n");
for(int i = 0; i < rows; i++) {
for(int j = 0; j < cols; j++) {
printf("%5d ", matrix[i][j]);
}
printf("\n");
}
return 0;
}

Common Operations on 2D Arrays

1. Sum of All Elements

#include <stdio.h>
int main() {
int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
int sum = 0;
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 3; j++) {
sum += matrix[i][j];
}
}
printf("Sum of all elements: %d\n", sum);  // 21
return 0;
}

2. Row-wise Sum

#include <stdio.h>
int main() {
int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
for(int i = 0; i < 3; i++) {
int row_sum = 0;
for(int j = 0; j < 3; j++) {
row_sum += matrix[i][j];
}
printf("Row %d sum: %d\n", i, row_sum);
}
return 0;
}
/* Output:
Row 0 sum: 6
Row 1 sum: 15
Row 2 sum: 24
*/

3. Column-wise Sum

#include <stdio.h>
int main() {
int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
for(int j = 0; j < 3; j++) {
int col_sum = 0;
for(int i = 0; i < 3; i++) {
col_sum += matrix[i][j];
}
printf("Column %d sum: %d\n", j, col_sum);
}
return 0;
}
/* Output:
Column 0 sum: 12
Column 1 sum: 15
Column 2 sum: 18
*/

4. Find Maximum Element

#include <stdio.h>
int main() {
int matrix[3][4] = {
{5, 8, 2, 11},
{9, 23, 4, 7},
{15, 3, 19, 6}
};
int max = matrix[0][0];
int max_row = 0, max_col = 0;
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 4; j++) {
if(matrix[i][j] > max) {
max = matrix[i][j];
max_row = i;
max_col = j;
}
}
}
printf("Maximum element: %d\n", max);
printf("Position: [%d][%d]\n", max_row, max_col);
return 0;
}

5. Transpose of a Matrix

#include <stdio.h>
int main() {
int original[2][3] = {{1, 2, 3}, {4, 5, 6}};
int transpose[3][2];
// Calculate transpose
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 3; j++) {
transpose[j][i] = original[i][j];
}
}
// Print original
printf("Original matrix (2×3):\n");
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 3; j++) {
printf("%d ", original[i][j]);
}
printf("\n");
}
// Print transpose
printf("\nTranspose matrix (3×2):\n");
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 2; j++) {
printf("%d ", transpose[i][j]);
}
printf("\n");
}
return 0;
}

6. Matrix Addition

#include <stdio.h>
int main() {
int A[2][2] = {{1, 2}, {3, 4}};
int B[2][2] = {{5, 6}, {7, 8}};
int C[2][2];
// Addition
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 2; j++) {
C[i][j] = A[i][j] + B[i][j];
}
}
// Result
printf("A + B =\n");
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 2; j++) {
printf("%d ", C[i][j]);
}
printf("\n");
}
return 0;
}
/* Output:
A + B =
6 8
10 12
*/

7. Matrix Multiplication

#include <stdio.h>
int main() {
int A[2][3] = {{1, 2, 3}, {4, 5, 6}};
int B[3][2] = {{7, 8}, {9, 10}, {11, 12}};
int result[2][2] = {0};
// Multiplication: A(2×3) × B(3×2) = C(2×2)
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 2; j++) {
for(int k = 0; k < 3; k++) {
result[i][j] += A[i][k] * B[k][j];
}
}
}
printf("Result of multiplication:\n");
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 2; j++) {
printf("%d ", result[i][j]);
}
printf("\n");
}
return 0;
}
/* Output:
58 64
139 154
*/

2D Array Memory Representation

#include <stdio.h>
int main() {
int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
printf("Memory addresses:\n");
for(int i = 0; i < 2; i++) {
for(int j = 0; j < 3; j++) {
printf("&matrix[%d][%d] = %p\n", i, j, &matrix[i][j]);
}
}
printf("\nAll elements are stored contiguously in row-major order!\n");
return 0;
}

3D Arrays (Quick Look)

#include <stdio.h>
int main() {
// 3D array: 2 layers × 3 rows × 4 columns
int cube[2][3][4] = {
{  // Layer 0
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
},
{  // Layer 1
{13, 14, 15, 16},
{17, 18, 19, 20},
{21, 22, 23, 24}
}
};
printf("cube[1][2][3] = %d\n", cube[1][2][3]);  // 24
return 0;
}

Common Mistakes

Mistake	Wrong	Correct
Wrong index order	`matrix[col][row]`	`matrix[row][col]`
Missing column size	`int arr[][]`	`int arr[][3]`
Index out of bounds	`matrix[3][2]` (3×3)	`matrix[2][2]`
Wrong loop bounds	`for(i<=rows)`	`for(i<rows)`

Quick Reference

Operation	Syntax Example
Declare	`int arr[3][4];`
Initialize	`int arr[2][2] = {{1,2},{3,4}};`
Access	`arr[row][col]`
Row count	`sizeof(arr)/sizeof(arr[0])`
Column count	`sizeof(arr[0])/sizeof(arr[0][0])`

Key Points

Row-major order - Elements stored row by row in memory
Column size is mandatory when omitting row size
Index starts at 0 (rows: 0 to rows-1, cols: 0 to cols-1)
Use nested loops to traverse (outer for rows, inner for columns)
2D arrays are arrays of 1D arrays

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

https://macronepal.com/understanding-the-c-srand-function
Explains how srand() initializes the pseudo-random number generator in C by setting a seed value. Using the same seed produces the same sequence, while time(NULL) gives different results each run.

2. C rand() Function Mechanics and Limitations

https://macronepal.com/c-rand-function-mechanics-and-limitations
Explains how rand() generates pseudo-random numbers between 0 and RAND_MAX, its deterministic nature, and limitations for security use cases.

3. C log() Function

https://macronepal.com/c-log-function-2
Covers natural logarithm calculation using <math.h> and its applications.

4. Mastering Date and Time in C

https://macronepal.com/mastering-date-and-time-in-c
Explains <time.h> functions like time(), clock(), difftime(), and struct tm.

5. Mastering time_t Type in C

https://macronepal.com/mastering-the-c-time_t-type-for-time-management
Explains time representation as seconds since Unix epoch and conversion functions.

6. C exp() Function

https://macronepal.com/c-exp-function-mechanics-and-implementation
Explains exponential function exp(x) and its scientific applications.

7. C log() Function (Alternate Guide)

https://macronepal.com/c-log-function
Comparison of log() and log10() with usage examples.

8. C log10() Function

https://macronepal.com/mastering-the-log10-function-in-c
Explains base-10 logarithm for engineering and scientific applications.

9. C tan() Function

https://macronepal.com/understanding-the-c-tan-function
Explains tangent function and radian-based calculations.

10. Random Numbers in C (Secure vs Predictable)

https://macronepal.com/mastering-c-random-numbers-for-secure-and-predictable-applications
Explains difference between rand() and secure randomness methods.

11. Free Online C Compiler

https://macronepal.com/free-online-c-code-compiler-2
Browser-based compiler for testing C programs instantly.

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

https://macronepal.com/c/mastering-functions-in-c-a-complete-guide/
Covers function structure, modular programming, and real-world usage.

Function Arguments in C

https://macronepal.com/c-function-arguments/
Explains how arguments are passed and used in function calls.

Function Parameters in C

https://macronepal.com/c-function-parameters/
Explains defining inputs for functions and matching them with arguments.

Function Declarations in C

https://macronepal.com/c-function-declarations-syntax-rules-and-best-practices/
Covers prototypes, syntax rules, and best practices.

Function Calls in C

https://macronepal.com/understanding-function-calls-in-c-syntax-mechanics-and-best-practices/
Explains execution flow and parameter handling during function calls.

Void Functions in C

https://macronepal.com/understanding-void-functions-in-c-syntax-patterns-and-best-practices/
Explains functions that do not return values.

Return Values in C

https://macronepal.com/c-return-values-mechanics-types-and-best-practices/
Explains different return types and how functions return results.

Pass-by-Value in C

https://macronepal.com/aws/understanding-pass-by-value-in-c-mechanics-implications-and-best-practices/
Explains how copies of variables are passed into functions.

Pass-by-Reference in C

https://macronepal.com/c/understanding-pass-by-reference-in-c-pointers-semantics-and-safe-practices/
Explains using pointers to modify original variables.

C strstr() Function

https://macronepal.com/aws/c-strstr-function/
Explains substring search inside strings in C.

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

https://macronepal.com/13757-2/
https://macronepal.com/13748-2/
https://macronepal.com/13747-2/
https://macronepal.com/13746-2/
https://macronepal.com/13745-2/
https://macronepal.com/13708-2/
https://macronepal.com/13707-2/
https://macronepal.com/13702-2/

Online Compilers

Complete Guide to Core & Advanced C Programming Concepts (Functions, Strings, Arrays, Loops, I/O, Control Flow)

https://macronepal.com/bash/building-blocks-of-c-a-complete-guide-to-functions/
Explains how functions in C work as reusable blocks of code, including declaration, definition, parameters, return values, and modular programming structure.

https://macronepal.com/bash/the-heart-of-text-processing-a-complete-guide-to-strings-in-c-2/
Explains how strings are handled in C using character arrays, string manipulation techniques, and common library functions for text processing.

https://macronepal.com/bash/the-cornerstone-of-data-organization-a-complete-guide-to-arrays-in-c/
Explains arrays in C as structured memory storage for multiple values, including indexing, initialization, and efficient data organization.

https://macronepal.com/bash/guaranteed-execution-a-complete-guide-to-the-do-while-loop-in-c/
Explains the do-while loop in C, where the loop body executes at least once before checking the condition.

https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-the-for-loop-in-c/
Explains the for loop in C, including initialization, condition checking, and increment/decrement for controlled iteration.

https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-while-loops-in-c/
Explains the while loop in C, focusing on condition-based repetition and proper loop control mechanisms.

https://macronepal.com/bash/beyond-if-else-a-complete-guide-to-switch-case-in-c/
Explains switch-case statements in C, enabling multi-branch decision-making based on variable values.

https://macronepal.com/bash/mastering-conditional-logic-a-complete-guide-to-if-else-statements-in-c/
Explains if-else statements in C for decision-making and controlling program flow based on conditions.

https://macronepal.com/bash/mastering-the-fundamentals-a-complete-guide-to-arithmetic-operations-in-c/
Explains arithmetic operations in C such as addition, subtraction, multiplication, division, and operator precedence.

https://macronepal.com/bash/foundation-of-c-programming-a-complete-guide-to-basic-input-output/
Explains basic input and output in C using scanf and printf for interacting with users and displaying results.

Online C Code Compiler
https://macronepal.com/free-online-c-code-compiler-2/