Table of Contents

What is an Array?

An array is a collection of same-type elements stored in contiguous memory locations with a single variable name. It allows you to store multiple values using one variable.

Array Declaration Syntax

data_type array_name[array_size];

Basic Declarations

int numbers[5];        // Array of 5 integers
float prices[10];      // Array of 10 floats
char name[20];         // Array of 20 characters (string)
double values[100];    // Array of 100 doubles

Ways to Declare and Initialize Arrays

1. Declaration Then Assignment

#include <stdio.h>
int main() {
int scores[5];          // Declaration
scores[0] = 85;         // Assign value at index 0
scores[1] = 90;
scores[2] = 78;
scores[3] = 92;
scores[4] = 88;
for(int i = 0; i < 5; i++) {
printf("scores[%d] = %d\n", i, scores[i]);
}
return 0;
}

2. Declaration with Initialization (Compile Time)

#include <stdio.h>
int main() {
int numbers[5] = {10, 20, 30, 40, 50};    // Full initialization
int values[5] = {1, 2};                    // Rest are auto-set to 0
printf("numbers[2] = %d\n", numbers[2]);   // 30
printf("values[2] = %d\n", values[2]);     // 0
printf("values[4] = %d\n", values[4]);     // 0
return 0;
}

3. Omitting Array Size (Auto-Detection)

#include <stdio.h>
int main() {
int numbers[] = {5, 10, 15, 20, 25};  // Size = 5 (auto-detected)
int size = sizeof(numbers) / sizeof(numbers[0]);
printf("Array size: %d\n", size);     // 5
printf("Numbers: ");
for(int i = 0; i < size; i++) {
printf("%d ", numbers[i]);
}
return 0;
}

4. Partial Initialization with Zero Fill

#include <stdio.h>
int main() {
int arr[8] = {1, 2, 3};  // arr[0]=1, arr[1]=2, arr[2]=3, rest=0
for(int i = 0; i < 8; i++) {
printf("arr[%d] = %d\n", i, arr[i]);
}
// Output: 1, 2, 3, 0, 0, 0, 0, 0
return 0;
}

5. Initialize All Elements to Zero

int arr[10] = {0};   // All 10 elements are 0
int arr2[5] = {};    // All 5 elements are 0 (C99+)

Array Types with Examples

Integer Array

int ages[4] = {25, 30, 22, 28};

Float Array

float temperatures[7] = {98.6, 99.1, 97.5, 98.0, 99.3, 98.8, 97.9};

Character Array (String)

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};  // Manual
char message[] = "Hello";                               // Simplified

Accessing Array Elements

Array indexing starts at 0 (first element) and ends at size-1 (last element).

#include <stdio.h>
int main() {
int marks[5] = {75, 82, 91, 68, 87};
// Accessing individual elements
printf("First mark: %d\n", marks[0]);      // 75
printf("Third mark: %d\n", marks[2]);      // 91
printf("Last mark: %d\n", marks[4]);       // 87
// Modifying elements
marks[1] = 85;      // Change second element
printf("Updated marks[1]: %d\n", marks[1]); // 85
return 0;
}

Common Array Operations

Input and Output Array Elements

#include <stdio.h>
int main() {
int arr[5];
// Input using loop
printf("Enter 5 numbers:\n");
for(int i = 0; i < 5; i++) {
printf("arr[%d] = ", i);
scanf("%d", &arr[i]);
}
// Output using loop
printf("\nYou entered: ");
for(int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}
return 0;
}

Calculate Sum and Average

#include <stdio.h>
int main() {
int numbers[6] = {10, 20, 30, 40, 50, 60};
int sum = 0;
for(int i = 0; i < 6; i++) {
sum += numbers[i];
}
float average = sum / 6.0;
printf("Sum = %d\n", sum);        // 210
printf("Average = %.2f\n", average); // 35.00
return 0;
}

Find Largest Element

#include <stdio.h>
int main() {
int arr[5] = {23, 56, 12, 89, 45};
int max = arr[0];
for(int i = 1; i < 5; i++) {
if(arr[i] > max) {
max = arr[i];
}
}
printf("Largest element: %d\n", max);  // 89
return 0;
}

Size of Array: `sizeof()` Operator

#include <stdio.h>
int main() {
int arr[10];
int size_in_bytes = sizeof(arr);
int element_size = sizeof(arr[0]);
int length = size_in_bytes / element_size;
printf("Array size in bytes: %d\n", size_in_bytes);  // 40 (if int=4 bytes)
printf("Element size: %d\n", element_size);          // 4
printf("Number of elements: %d\n", length);          // 10
return 0;
}

Multi-Dimensional Arrays (2D)

#include <stdio.h>
int main() {
// 2D array: 3 rows, 4 columns
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
// Accessing elements
printf("matrix[1][2] = %d\n", matrix[1][2]);  // 7 (row 1, col 2)
// Display entire matrix
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 4; j++) {
printf("%3d ", matrix[i][j]);
}
printf("\n");
}
return 0;
}

Common Mistakes to Avoid

Mistake	Wrong	Correct
Index out of bounds	`int arr[5]; arr[5]=10;`	`arr[4]=10;`
Negative index	`arr[-1]=5;`	Use positive index
Wrong initialization	`int arr[5]=0;`	`int arr[5]={0};`
Missing semicolon	`int arr[5]`	`int arr[5];`
Variable size (old C)	`int n=5; int arr[n];`	Use constant or dynamic allocation

Quick Reference Table

Declaration	Meaning	Valid Indexes
`int a[10];`	10 integers	0 to 9
`float b[5];`	5 floats	0 to 4
`char c[20];`	20 chars	0 to 19
`double d[100];`	100 doubles	0 to 99
`int e[] = {1,2,3};`	Size auto = 3	0 to 2

Key Points to Remember

Array index always starts at 0
All elements must be same data type
Elements are stored in continuous memory
Array size must be a constant (except variable-length arrays in C99)
No bounds checking - you must ensure index is valid
Array name is a pointer to first element
Never access arr[size] (last valid index is size-1)

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/