C Accessing Array Elements

Array elements are accessed using an index number inside square brackets []. Indexing starts at 0 (first element) and goes up to size - 1 (last element).


Basic Syntax

arrayName[index]; // Access element at specific position arrayName[index] = value; // Assign value to specific position

Example 1: Access and Print Elements

#include <stdio.h> int main() { int numbers[5] = {10, 20, 30, 40, 50}; // Access individual elements printf("First element: %d\n", numbers[0]); // Index 0 printf("Second element: %d\n", numbers[1]); // Index 1 printf("Third element: %d\n", numbers[2]); // Index 2 printf("Fourth element: %d\n", numbers[3]); // Index 3 printf("Fifth element: %d\n", numbers[4]); // Index 4 return 0; }

Output:

First element: 10 Second element: 20 Third element: 30 Fourth element: 40 Fifth element: 50

Example 2: Modify Elements

#include <stdio.h> int main() { int scores[3] = {75, 80, 90}; printf("Original: %d %d %d\n", scores[0], scores[1], scores[2]); // Modify elements scores[0] = 95; // Change first element scores[1] += 5; // Add 5 to second element printf("Modified: %d %d %d\n", scores[0], scores[1], scores[2]); return 0; }

Output:

Original: 75 80 90 Modified: 95 85 90

Example 3: Loop Through Array

#include <stdio.h> int main() { int prices[6] = {10, 20, 30, 40, 50, 60}; // Reading all elements printf("All prices: "); for(int i = 0; i < 6; i++) { printf("%d ", prices[i]); } // Sum all elements int sum = 0; for(int i = 0; i < 6; i++) { sum += prices[i]; } printf("\nTotal sum: %d\n", sum); return 0; }

Output:

All prices: 10 20 30 40 50 60 Total sum: 210

Example 4: User Input into Array

#include <stdio.h> int main() { int marks[5]; // Get user input printf("Enter 5 marks:\n"); for(int i = 0; i < 5; i++) { printf("Index %d: ", i); scanf("%d", &marks[i]); // & needed for scanf } // Display entered values printf("\nYou entered: "); for(int i = 0; i < 5; i++) { printf("%d ", marks[i]); } return 0; }

Example 5: Find Largest Element

#include <stdio.h> int main() { int arr[] = {45, 12, 89, 34, 67, 23, 99, 11}; int size = sizeof(arr) / sizeof(arr[0]); // Calculate array size int max = arr[0]; // Assume first is largest for(int i = 1; i < size; i++) { if(arr[i] > max) { max = arr[i]; } } printf("Largest element: %d\n", max); return 0; }

Output:

Largest element: 99

Example 6: Reverse an Array

#include <stdio.h> int main() { int arr[] = {1, 2, 3, 4, 5}; int size = 5; printf("Original: "); for(int i = 0; i < size; i++) { printf("%d ", arr[i]); } // Reverse the array for(int i = 0; i < size / 2; i++) { int temp = arr[i]; arr[i] = arr[size - 1 - i]; arr[size - 1 - i] = temp; } printf("\nReversed: "); for(int i = 0; i < size; i++) { printf("%d ", arr[i]); } return 0; }

Output:

Original: 1 2 3 4 5 Reversed: 5 4 3 2 1

Access Patterns Table

PatternCodeResult
First elementarr[0]First value
Last elementarr[size-1]Last value
Every elementfor(i=0; i<size; i++)All values
Every otherfor(i=0; i<size; i+=2)Index 0,2,4…
Backwardsfor(i=size-1; i>=0; i--)Reverse order

Common Mistakes

// ❌ WRONG - Index out of bounds int arr[5] = {1,2,3,4,5}; printf("%d", arr[5]); // Index 5 doesn't exist (0-4 are valid) // ❌ WRONG - Using value instead of index int arr[5] = {1,2,3,4,5}; int x = 3; printf("%d", arr[x]); // This prints arr[3] = 4 (works but confusing) // ❌ WRONG - Forgetting & in scanf int arr[5]; scanf("%d", arr[0]); // Wrong - missing & scanf("%d", &arr[0]); // Correct // ✅ CORRECT - Always stay within bounds printf("%d", arr[4]); // Last element is size-1

Accessing with Pointers (Advanced)

#include <stdio.h> int main() { int arr[4] = {10, 20, 30, 40}; // Array name is pointer to first element printf("arr[0] = %d\n", arr[0]); printf("*(arr) = %d\n", *(arr)); // Same as arr[0] printf("*(arr+2) = %d\n", *(arr+2)); // Same as arr[2] // Both syntaxes work printf("Value at index 3: %d = %d\n", arr[3], *(arr+3)); return 0; }

Output:

arr[0] = 10 *(arr) = 10 *(arr+2) = 30 Value at index 3: 40 = 40

Valid Index Range

Array SizeValid IndicesInvalid Indices
int arr[5]0, 1, 2, 3, 4-1, 5, 6, 100
int arr[10]0 to 9-5, 10, 20
int arr[100]0 to 99100, 150, -1

Important: C does NOT check if index is valid. Going out of bounds causes undefined behavior (crashes, wrong data, or silent corruption).


Quick Summary

OperationCodeNotes
Access elementarr[i]i must be within 0 to size-1
Change elementarr[i] = valueValue must match array type
Loop throughfor(i=0; i<size; i++)Most common pattern
First elementarr[0]Always valid if size > 0
Last elementarr[size-1]Use sizeof to get size
Input elementscanf("%d", &arr[i])& operator required

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

https://macronepal.com/mastering-c-variadic-macros-for-flexible-debugging/
https://macronepal.com/mastering-the-stdc-macro-in-c/
https://macronepal.com/c-time-macro-mechanics-and-usage/
https://macronepal.com/understanding-the-c-date-macro/
https://macronepal.com/c-file-type/
https://macronepal.com/mastering-c-line-macro-for-debugging-and-diagnostics/
https://macronepal.com/mastering-predefined-macros-in-c/
https://macronepal.com/c-error-directive-mechanics-and-usage/
https://macronepal.com/understanding-the-c-pragma-directive/
https://macronepal.com/c-include-directive/


C Structures, Memory, Scope & Linkage

https://macronepal.com/mastering-structures-in-c/
https://macronepal.com/c-structure-declaration-mechanics-and-usage/
https://macronepal.com/c-structure-initialization-mechanics-and-best-practices/
https://macronepal.com/mastering-c-structure-member-access-for-reliable-data-handling/
https://macronepal.com/c-nested-structures/
https://macronepal.com/mastering-arrays-of-structures-in-c/
https://macronepal.com/c-structure-pointers-mechanics-and-implementation/
https://macronepal.com/understanding-c-structure-parameter-passing-mechanics/
https://macronepal.com/mastering-c-returning-structures-for-efficient-data-flow/
https://macronepal.com/c-self-referential-structures/
https://macronepal.com/mastering-structure-alignment-in-c/
https://macronepal.com/c-structure-padding-mechanics-and-optimization/
https://macronepal.com/understanding-c-flexible-array-members-mechanics-and-usage/
https://macronepal.com/mastering-c-anonymous-structures-for-flattened-data-layouts/
https://macronepal.com/c-unions/
https://macronepal.com/mastering-c-name-mangling-and-symbol-decoration/
https://macronepal.com/c-no-linkage-mechanics-and-scope-isolation/
https://macronepal.com/understanding-c-internal-linkage-mechanics-and-architecture/


C Scope, Storage Classes & Typedef

https://macronepal.com/mastering-function-prototype-scope-in-c/
https://macronepal.com/c-function-scope-mechanics-and-visibility/
https://macronepal.com/understanding-c-file-scope-mechanics-and-architecture/
https://macronepal.com/mastering-c-scope-rules-for-predictable-name-resolution/
https://macronepal.com/c-scope-rules/
https://macronepal.com/mastering-c-register-storage-class-for-historical-context-and-modern-alternatives/
https://macronepal.com/mastering-_thread_local-in-c/
https://macronepal.com/c-extern-storage-class-mechanics-and-usage/
https://macronepal.com/understanding-the-c-static-storage-class-mechanics-and-usage/
https://macronepal.com/c-auto-storage-class/
https://macronepal.com/c-typedef-with-pointers/


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

https://macronepal.com/free-html-online-code-compiler/
https://macronepal.com/free-online-python-code-compiler/
https://macronepal.com/free-online-python2-code-compiler/
https://macronepal.com/free-online-java-code-compiler/
https://macronepal.com/free-online-javascript-code-compiler/
https://macronepal.com/free-online-node-js-code-compiler/
https://macronepal.com/free-online-c-code-compiler/
https://macronepal.com/free-online-c-code-compiler-2/
https://macronepal.com/free-online-c-code-compiler-3/
https://macronepal.com/free-online-php-code-compiler/
https://macronepal.com/free-online-ruby-code-compiler/
https://macronepal.com/free-online-perl-code-compiler/
https://macronepal.com/free-online-lua-code-compiler/
https://macronepal.com/free-online-tcl-code-compiler/
https://macronepal.com/free-online-groovy-code-compiler/
https://macronepal.com/free-online-j-shell-code-compiler/
https://macronepal.com/free-online-haskell-code-compiler/
https://macronepal.com/free-online-scala-code-compiler/
https://macronepal.com/free-online-common-lisp-code-compiler/
https://macronepal.com/free-online-d-code-compiler/
https://macronepal.com/free-online-ada-code-compiler/
https://macronepal.com/free-erlang-code-compiler/
https://macronepal.com/free-online-assembly-code-compiler/

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/

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper