C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Understand the deep connection between pointers and arrays in C, array name as pointer, pointer-based array access, and key differences with practical examples.
One of the most important concepts in C is the intimate relationship between pointers and arrays. They are not the same thing — but they're so closely related that in many contexts, they behave identically. Understanding exactly where they overlap and where they differ is key to writing correct and efficient C code.
The Fundamental Connection
When you use an array name in an expression, it automatically "decays" into a pointer to its first element:
Example
int arr[5] = {10, 20, 30, 40, 50};
// In most contexts:
// arr is equivalent to &arr[0]
// *arr is equivalent to arr[0]
int arr[5] = {10, 20, 30, 40, 50};
Array name 'arr' decays to pointer to first element:
arr → &arr[0] → 0x1000
┌──────┬──────┬──────┬──────┬──────┐
│ 10 │ 20 │ 30 │ 40 │ 50 │
└──────┴──────┴──────┴──────┴──────┘
0x1000 0x1004 0x1008 0x100C 0x1010
↑
arr (points here)
Equivalent Access Methods
There are multiple ways to access the same array element:
Example
#include <stdio.h>
int main() {
int arr[] = {100, 200, 300, 400, 500};
int *ptr = arr; // ptr points to arr[0]
// All of these access arr[2] (value: 300)
printf("arr[2] = %d\n", arr[2]);
printf("*(arr + 2) = %d\n", *(arr + 2));
printf("ptr[2] = %d\n", ptr[2]);
printf("*(ptr + 2) = %d\n", *(ptr + 2));
printf("2[arr] = %d\n", 2[arr]); // Yes, this works!
return 0;
}
Output
arr[2] = 300 *(arr + 2) = 300 ptr[2] = 300 *(ptr + 2) = 300 2[arr] = 300
The subscript operator [] is actually defined as: a[b] ≡ *(a + b). Since addition is commutative, a[b] = b[a] — which is why 2[arr] works (though you should never write it that way in real code!).
Using Pointers to Traverse Arrays
Example
#include <stdio.h>
int main() {
int arr[] = {5, 10, 15, 20, 25, 30};
int n = sizeof(arr) / sizeof(arr[0]);
// Traverse using a moving pointer
int *ptr = arr;
printf("Element | Address | ptr offset\n");
printf("--------|------------|----------\n");
for (int i = 0; i < n; i++) {
printf(" %2d | %p | ptr + %d\n", *ptr, (void*)ptr, i);
ptr++;
}
return 0;
}
Output
Element | Address | ptr offset --------|------------|---------- 5 | 0x7ffd0010 | ptr + 0 10 | 0x7ffd0014 | ptr + 1 15 | 0x7ffd0018 | ptr + 2 20 | 0x7ffd001c | ptr + 3 25 | 0x7ffd0020 | ptr + 4 30 | 0x7ffd0024 | ptr + 5
Key Differences: Array vs Pointer
Despite their similarities, arrays and pointers are not the same:
Example
#include <stdio.h>
int main() {
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
// Difference 1: sizeof
printf("sizeof(arr) = %lu (total array size)\n", sizeof(arr));
printf("sizeof(ptr) = %lu (pointer size only)\n", sizeof(ptr));
// Difference 2: Address-of
printf("\n&arr = %p (address of entire array)\n", (void*)&arr);
printf("&ptr = %p (address of pointer variable)\n", (void*)&ptr);
printf("arr = %p (decays to &arr[0])\n", (void*)arr);
printf("ptr = %p (value stored in ptr)\n", (void*)ptr);
return 0;
}
Output
sizeof(arr) = 20 (total array size) sizeof(ptr) = 8 (pointer size only) &arr = 0x7ffd00100010 (address of entire array) &ptr = 0x7ffd00100028 (address of pointer variable) arr = 0x7ffd00100010 (decays to &arr[0]) ptr = 0x7ffd00100010 (value stored in ptr)
Complete Difference Table
| Feature | int arr[5] | int *ptr |
|---|---|---|
sizeof() | Total array bytes (20) | Pointer size (4 or 8) |
| Modifiable? | Cannot reassign (arr = ...) | Can reassign (ptr = ...) |
| Memory | Contains the actual data | Contains only an address |
&variable | Address of array block | Address of pointer variable |
| Storage | Usually stack | Variable that can point anywhere |
| Existence | Always valid while in scope | May be NULL or dangling |
Example
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
// arr = ptr; // ERROR! Cannot assign to array name
ptr = arr + 2; // OK — pointer can be reassigned
// arr++; // ERROR! Cannot increment array name
ptr++; // OK — pointer can be incremented
Pointer to an Entire Array
There's a subtle difference between int *p (pointer to int) and int (*p)[5] (pointer to array of 5 ints):
Example
#include <stdio.h>
int main() {
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr; // Pointer to first element
int (*ap)[5] = &arr; // Pointer to the entire array
printf("p = %p\n", (void*)p);
printf("p + 1 = %p (advances %lu bytes)\n", (void*)(p + 1),
(unsigned long)((char*)(p+1) - (char*)p));
printf("ap = %p\n", (void*)ap);
printf("ap + 1 = %p (advances %lu bytes)\n", (void*)(ap + 1),
(unsigned long)((char*)(ap+1) - (char*)ap));
return 0;
}
Output
p = 0x7ffd0010 p + 1 = 0x7ffd0014 (advances 4 bytes) ap = 0x7ffd0010 ap + 1 = 0x7ffd0024 (advances 20 bytes)
p + 1 advances by one int (4 bytes), while ap + 1 advances by one entire array of 5 ints (20 bytes).
Array of Pointers vs Pointer to Array
Example
#include <stdio.h>
int main() {
// Array of pointers: 3 pointers, each pointing to an int
int a = 10, b = 20, c = 30;
int *arrOfPtrs[3] = {&a, &b, &c};
printf("Array of pointers:\n");
for (int i = 0; i < 3; i++) {
printf(" arrOfPtrs[%d] = %p → %d\n", i, (void*)arrOfPtrs[i], *arrOfPtrs[i]);
}
// Pointer to array: single pointer to array of 3 ints
int nums[3] = {100, 200, 300};
int (*ptrToArr)[3] = &nums;
printf("\nPointer to array:\n");
for (int i = 0; i < 3; i++) {
printf(" (*ptrToArr)[%d] = %d\n", i, (*ptrToArr)[i]);
}
return 0;
}
Output
Array of pointers: arrOfPtrs[0] = 0x7ffd001c → 10 arrOfPtrs[1] = 0x7ffd0020 → 20 arrOfPtrs[2] = 0x7ffd0024 → 30 Pointer to array: (*ptrToArr)[0] = 100 (*ptrToArr)[1] = 200 (*ptrToArr)[2] = 300
| int *arrOfPtrs[3] | (Array of 3 pointers) |
| int (*ptrToArr)[3] | (One pointer to array of 3) |
| │ &nums ─┼─────── | │100 │200 │300 │ Points to entire array |
Practical Example: Pointer-Based String Array
Example
#include <stdio.h>
int main() {
// Array of string pointers (efficient — no wasted space)
const char *languages[] = {
"C",
"Python",
"JavaScript",
"Rust",
"Go"
};
int n = sizeof(languages) / sizeof(languages[0]);
printf("Programming languages:\n");
for (int i = 0; i < n; i++) {
printf(" %d. %s (at %p)\n", i + 1, languages[i], (void*)languages[i]);
}
// Compare with 2D char array (wastes space)
char langs2D[5][15] = {"C", "Python", "JavaScript", "Rust", "Go"};
printf("\nMemory comparison:\n");
printf(" Pointer array: %lu bytes\n", sizeof(languages));
printf(" 2D char array: %lu bytes\n", sizeof(langs2D));
return 0;
}
Output
Programming languages: 1. C (at 0x400800) 2. Python (at 0x400802) 3. JavaScript (at 0x400809) 4. Rust (at 0x400814) 5. Go (at 0x400819) Memory comparison: Pointer array: 40 bytes 2D char array: 75 bytes
When Decay Does NOT Happen
Array-to-pointer decay does not occur in these cases:
sizeof(arr)— returns full array size&arr— gives pointer to entire array, not pointer to first element- String literal initialization:
char str[] = "Hello"copies the string
Interview Questions
Q1: Are arrays and pointers the same thing in C?
No. An array is a fixed-size block of contiguous memory; a pointer is a variable holding an address. However, in most expressions, an array name decays to a pointer to its first element, which is why they often appear interchangeable.
Q2: What does arr + 1 return when arr is int arr[5]?
It returns a pointer to arr[1] — the address of the second element. The compiler adds 1 × sizeof(int) bytes to the base address. To get the value, you'd dereference it: *(arr + 1).
**Q3: What's the difference between int *p[10] and int (*p)[10]?**
int *p[10] is an array of 10 pointers to int. int (*p)[10] is a pointer to an array of 10 ints. The parentheses change the binding of * with p.
Q4: Why does sizeof(arr) give the full size inside main but pointer size inside a function?
Because when passed to a function, the array decays to a pointer. The function parameter int arr[] is actually int *arr. Inside main, arr is still an array, so sizeof reports the total allocated memory.
Summary
- Array names decay to pointers to their first element in most expressions
arr[i]is equivalent to*(arr + i)— both use pointer arithmetic internally- Arrays cannot be reassigned or incremented; pointers can
sizeof(array)gives total size;sizeof(pointer)gives pointer sizeint *p[N]is array of pointers;int (*p)[N]is pointer to array- Decay doesn't occur with
sizeof,&, or string literal initialization - Pointer-based string arrays are more memory-efficient than 2D char arrays
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Pointers and Arrays in C - The Relationship Explained.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, pointers, and, arrays, pointers and arrays in c - the relationship explained
Related C Programming Topics
Continue learning this concept
PointersPointers and Functions in C - Pass by ReferenceLearn how to use pointers with functions in C for pass-by-reference, returning pointers, function pointers, and callback patterns with practical examples.PointersDouble Pointers in C - Pointer to PointerMaster double pointers (pointer to pointer) in C including declaration, usage with functions, dynamic 2D arrays, and practical applications with memory diagrams.PointersPointer Arithmetic in C ProgrammingLearn pointer arithmetic in C including increment, decrement, addition, subtraction, pointer difference, and comparison with detailed memory diagrams and examples.PointersPointer Declaration and Initialization in CLearn how to declare and initialize pointers in C using * and & operators, pointer types, multiple pointer declarations, and const pointers with examples.PointersPointer Programs in C - Swap, String Reversal, Dynamic AllocationPractice essential pointer programs in C including swap using pointers, string operations with pointers, dynamic memory allocation, and pointer-based data manipulation.PointersIntroduction to Pointers in C ProgrammingUnderstand what pointers are in C, why they are essential, how memory addresses work, and the fundamentals of pointer concepts with visual memory diagrams.