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
Learn pointer arithmetic in C including increment, decrement, addition, subtraction, pointer difference, and comparison with detailed memory diagrams and examples.
Pointer arithmetic is what makes C pointers truly powerful for array traversal and memory manipulation. Unlike regular arithmetic, pointer operations are automatically scaled by the size of the data type the pointer points to. This means incrementing an int* moves it forward by 4 bytes (not 1), making it naturally align with the next integer in memory.
How Pointer Arithmetic Works
When you perform arithmetic on a pointer, the compiler multiplies or divides by sizeof(pointed_type):
| p + 1 | address increases by 4 bytes |
| p + 3 | address increases by 12 bytes |
| p - 1 | address decreases by 4 bytes |
| c + 1 | address increases by 1 byte |
| c + 5 | address increases by 5 bytes |
| d + 1 | address increases by 8 bytes |
| d + 2 | address increases by 16 bytes |
Allowed Pointer Operations
| Operation | Allowed? | Description |
|---|---|---|
| pointer + integer | ✅ Yes | Move forward N elements |
| pointer - integer | ✅ Yes | Move backward N elements |
| pointer - pointer | ✅ Yes | Distance between elements |
| pointer ++ / -- | ✅ Yes | Move to next/previous element |
| pointer + pointer | ❌ No | Meaningless — two addresses |
| pointer * integer | ❌ No | Meaningless |
| pointer / integer | ❌ No | Meaningless |
Pointer Increment and Decrement
Example
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40, 50};
int *ptr = arr; // Points to first element
printf("Initial: ptr = %p, *ptr = %d\n", (void*)ptr, *ptr);
ptr++; // Move to next integer (advance by sizeof(int) = 4 bytes)
printf("After ptr++: ptr = %p, *ptr = %d\n", (void*)ptr, *ptr);
ptr++;
printf("After ptr++: ptr = %p, *ptr = %d\n", (void*)ptr, *ptr);
ptr--; // Move back one integer
printf("After ptr--: ptr = %p, *ptr = %d\n", (void*)ptr, *ptr);
return 0;
}
Output
Initial: ptr = 0x7ffd12340010, *ptr = 10 After ptr++: ptr = 0x7ffd12340014, *ptr = 20 After ptr++: ptr = 0x7ffd12340018, *ptr = 30 After ptr--: ptr = 0x7ffd12340014, *ptr = 20
Memory Visualization
| Address | 0x010 0x014 0x018 0x01C 0x020 |
| Value | │ 10 │ 20 │ 30 │ 40 │ 50 │ |
| Value | │ 10 │ 20 │ 30 │ 40 │ 50 │ |
Pointer Addition and Subtraction
You can add or subtract integers to/from pointers:
Example
#include <stdio.h>
int main() {
int arr[] = {100, 200, 300, 400, 500};
int *ptr = arr;
printf("*(ptr + 0) = %d\n", *(ptr + 0)); // arr[0]
printf("*(ptr + 1) = %d\n", *(ptr + 1)); // arr[1]
printf("*(ptr + 2) = %d\n", *(ptr + 2)); // arr[2]
printf("*(ptr + 4) = %d\n", *(ptr + 4)); // arr[4]
// Start from end
int *end = &arr[4];
printf("\n*(end - 1) = %d\n", *(end - 1)); // arr[3]
printf("*(end - 3) = %d\n", *(end - 3)); // arr[1]
return 0;
}
Output
*(ptr + 0) = 100 *(ptr + 1) = 200 *(ptr + 2) = 300 *(ptr + 4) = 500 *(end - 1) = 400 *(end - 3) = 200
Pointer Difference (Subtraction of Two Pointers)
Subtracting two pointers of the same type gives the number of elements between them:
Example
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40, 50};
int *p1 = &arr[1];
int *p2 = &arr[4];
printf("p1 points to arr[1] at %p\n", (void*)p1);
printf("p2 points to arr[4] at %p\n", (void*)p2);
printf("p2 - p1 = %ld elements\n", p2 - p1);
printf("Byte difference = %ld bytes\n", (char*)p2 - (char*)p1);
return 0;
}
Output
p1 points to arr[1] at 0x7ffd3a1c0024 p2 points to arr[4] at 0x7ffd3a1c0030 p2 - p1 = 3 elements Byte difference = 12 bytes
The result is the number of elements (not bytes): (0x030 - 0x024) / sizeof(int) = 12 / 4 = 3.
Traversing Arrays with Pointer Arithmetic
This is the most practical application of pointer arithmetic:
Example
#include <stdio.h>
int main() {
int arr[] = {5, 15, 25, 35, 45, 55};
int n = sizeof(arr) / sizeof(arr[0]);
// Method 1: Using index notation
printf("Index notation: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
// Method 2: Using pointer arithmetic
printf("\nPointer notation: ");
for (int i = 0; i < n; i++) {
printf("%d ", *(arr + i));
}
// Method 3: Moving pointer
printf("\nMoving pointer: ");
int *ptr = arr;
for (int i = 0; i < n; i++) {
printf("%d ", *ptr);
ptr++;
}
// Method 4: Pointer comparison
printf("\nPointer compare: ");
int *end = arr + n;
for (int *p = arr; p < end; p++) {
printf("%d ", *p);
}
printf("\n");
return 0;
}
Output
Index notation: 5 15 25 35 45 55 Pointer notation: 5 15 25 35 45 55 Moving pointer: 5 15 25 35 45 55 Pointer compare: 5 15 25 35 45 55
Pointer Comparison
Pointers can be compared using relational operators (<, >, <=, >=, ==, !=):
Example
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40, 50};
int *start = &arr[0];
int *end = &arr[4];
int *mid = &arr[2];
printf("start < end? %s\n", start < end ? "Yes" : "No");
printf("start == mid? %s\n", start == mid ? "Yes" : "No");
printf("mid < end? %s\n", mid < end ? "Yes" : "No");
// Practical use: pointer-based loop
printf("\nElements: ");
int *p = start;
while (p <= end) {
printf("%d ", *p);
p++;
}
printf("\n");
return 0;
}
Output
start < end? Yes start == mid? No mid < end? Yes Elements: 10 20 30 40 50
Effect of Data Type on Arithmetic
Example
#include <stdio.h>
int main() {
char c_arr[5];
int i_arr[5];
double d_arr[5];
char *cp = c_arr;
int *ip = i_arr;
double *dp = d_arr;
printf("Type | ptr | ptr+1 | Difference\n");
printf("--------|----------|----------|----------\n");
printf("char* | %p | %p | %ld byte\n", (void*)cp, (void*)(cp+1), (long)((char*)(cp+1) - (char*)cp));
printf("int* | %p | %p | %ld bytes\n", (void*)ip, (void*)(ip+1), (long)((char*)(ip+1) - (char*)ip));
printf("double* | %p | %p | %ld bytes\n", (void*)dp, (void*)(dp+1), (long)((char*)(dp+1) - (char*)dp));
return 0;
}
Output
Type | ptr | ptr+1 | Difference --------|----------|----------|---------- char* | 0x7ffd001 | 0x7ffd002 | 1 byte int* | 0x7ffd010 | 0x7ffd014 | 4 bytes double* | 0x7ffd020 | 0x7ffd028 | 8 bytes
Practical Example: String Length Using Pointer Arithmetic
Example
#include <stdio.h>
int stringLength(const char *str) {
const char *end = str;
while (*end != '\0') {
end++;
}
return end - str; // Pointer difference = character count
}
int main() {
char msg[] = "Hello, Pointers!";
printf("Length of \"%s\" = %d\n", msg, stringLength(msg));
return 0;
}
Output
Length of "Hello, Pointers!" = 16
Pre-increment vs Post-increment with Pointers
Be careful with operator precedence:
Example
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40};
int *p = arr;
printf("*p++ = %d\n", *p++); // Gets *p (10), THEN increments p
printf("*p = %d\n", *p); // p now at arr[1]
printf("*++p = %d\n", *++p); // Increments p FIRST, then gets *p (30)
printf("++*p = %d\n", ++*p); // Increments the VALUE at p (30→31)
return 0;
}
Output
*p++ = 10 *p = 20 *++p = 30 ++*p = 31
| Expression | Meaning |
|---|---|
*p++ | Use value at p, then advance p |
*++p | Advance p, then use value at p |
++*p | Increment value at p (don't move p) |
(*p)++ | Use value at p, then increment value |
Interview Questions
Q1: What is the result of subtracting two pointers?
It gives the number of elements (not bytes) between them. The compiler divides the byte difference by sizeof(pointed_type). Both pointers must point to elements of the same array; otherwise, the behavior is undefined.
Q2: Why can't you add two pointers?
Adding two memory addresses produces a meaningless result — there's no logical interpretation for summing two locations. Subtraction gives a distance (meaningful), but addition gives no useful value.
**Q3: What does *(arr + i) mean and how does it relate to arr[i]?**
They are exactly equivalent. arr[i] is syntactic sugar for *(arr + i). The compiler computes the address arr + i * sizeof(type) and dereferences it. Interestingly, i[arr] is also valid C (because addition is commutative).
Q4: What happens if you increment a pointer past the end of an array?
Moving one past the last element is allowed (for loop termination comparisons), but dereferencing it is undefined behavior. Moving further beyond that is undefined even without dereferencing.
Summary
- Pointer arithmetic is scaled by
sizeof(pointed_type)—ptr+1advances by one element, not one byte - Only addition/subtraction with integers and subtraction between pointers are valid
- Pointer difference gives element count between two addresses in the same array
*p++dereferences first then advances;*++padvances first then dereferences- Pointer comparison works for pointers into the same array
- Array indexing
arr[i]is equivalent to*(arr + i)— pointer arithmetic under the hood
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Pointer Arithmetic in C Programming.
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, pointer, arithmetic, pointer arithmetic in c programming
Related C Programming Topics
Continue learning this concept
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.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.PointersPointers and Arrays in C - The Relationship ExplainedUnderstand the deep connection between pointers and arrays in C, array name as pointer, pointer-based array access, and key differences with practical examples.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.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.