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
Master increment (++) and decrement (--) operators in C. Understand the difference between prefix and postfix, common pitfalls, undefined behavior, and practical usage in loops and expressions.
The increment (++) and decrement (--) operators are unary operators that add or subtract 1 from a variable. They're among the most frequently used operators in C — you'll see them in virtually every loop, counter, and pointer operation. But the distinction between prefix and postfix forms trips up many programmers, even experienced ones.
Basic Syntax
| Operator | Name | Effect |
|---|---|---|
++x | Pre-increment | Increment x, then use the new value |
x++ | Post-increment | Use the current value, then increment x |
--x | Pre-decrement | Decrement x, then use the new value |
x-- | Post-decrement | Use the current value, then decrement x |
Both forms ultimately change the variable by 1 — the difference lies in when the change takes effect in an expression.
Prefix vs Postfix: The Key Difference
Example
#include <stdio.h>
int main() {
int a = 5, b = 5;
// Pre-increment: increment FIRST, then use
printf("Pre-increment: ++a = %d\n", ++a); // a becomes 6, prints 6
printf("a is now: %d\n\n", a);
// Post-increment: use FIRST, then increment
printf("Post-increment: b++ = %d\n", b++); // prints 5, then b becomes 6
printf("b is now: %d\n", b);
return 0;
}
Output
Pre-increment: ++a = 6 a is now: 6 Post-increment: b++ = 5 b is now: 6
Think of it this way:
- Prefix (
++x): "Increment, then give me the value" — the operator comes first, so it acts first - Postfix (
x++): "Give me the value, then increment" — the operator comes after, so it acts after
Standalone Statements
When used as standalone statements (not inside larger expressions), prefix and postfix behave identically:
Example
#include <stdio.h>
int main() {
int x = 10, y = 10;
++x; // x becomes 11
y++; // y becomes 11
printf("x = %d, y = %d\n", x, y); // Both are 11
--x; // x becomes 10
y--; // y becomes 10
printf("x = %d, y = %d\n", x, y); // Both are 10
return 0;
}
Output
x = 10, y = 10 x = 10, y = 10
In Expressions: Where It Matters
The difference becomes critical when ++/-- is part of a larger expression:
Example
#include <stdio.h>
int main() {
int a, b, result;
// Example 1: Assignment with post-increment
a = 5;
b = a++; // b gets 5 (old value), then a becomes 6
printf("a=%d, b=%d\n", a, b);
// Example 2: Assignment with pre-increment
a = 5;
b = ++a; // a becomes 6 first, then b gets 6
printf("a=%d, b=%d\n", a, b);
// Example 3: In arithmetic
a = 3;
result = a++ + 10; // result = 3 + 10 = 13, then a becomes 4
printf("result=%d, a=%d\n", result, a);
a = 3;
result = ++a + 10; // a becomes 4 first, result = 4 + 10 = 14
printf("result=%d, a=%d\n", result, a);
return 0;
}
Output
a=6, b=5 a=6, b=6 result=13, a=4 result=14, a=4
Decrement Operators
Decrement operators work exactly the same way but subtract 1:
c example
#include <stdio.h>
int main() {
int x = 10;
printf("x = %d\n", x);
printf("--x = %d\n", --x); // x becomes 9, prints 9
printf("x-- = %d\n", x--); // prints 9, then x becomes 8
printf("x = %d\n", x); // 8
// Countdown
int countdown = 5;
printf("\nCountdown: ");
while (countdown > 0) {
printf("%d ", countdown--);
}
printf("Blast off!\n");
return 0;
}Output
x = 10 --x = 9 x-- = 9 x = 8 Countdown: 5 4 3 2 1 Blast off!
Usage in Loops
This is where you'll use increment/decrement operators most often:
Example
#include <stdio.h>
int main() {
// In for loops (prefix and postfix work the same for standalone increment)
printf("Using i++: ");
for (int i = 0; i < 5; i++) {
printf("%d ", i);
}
printf("\n");
printf("Using ++i: ");
for (int i = 0; i < 5; ++i) {
printf("%d ", i);
}
printf("\n");
// While loop with post-decrement
int n = 5;
int factorial = 1;
while (n > 0) {
factorial *= n--;
}
printf("5! = %d\n", factorial);
// Array traversal
int arr[] = {10, 20, 30, 40, 50};
int index = 0;
printf("Elements: ");
while (index < 5) {
printf("%d ", arr[index++]);
}
printf("\n");
return 0;
}
Output
Using i++: 0 1 2 3 4 Using ++i: 0 1 2 3 4 5! = 120 Elements: 10 20 30 40 50
Note: In a for loop's update expression (i++ vs ++i), both produce the same result because the expression value is discarded. However, for C++ iterators, ++i is preferred for efficiency.
With Pointers
Increment and decrement operators are extensively used with pointers:
Example
#include <stdio.h>
int main() {
int arr[] = {100, 200, 300, 400, 500};
int *ptr = arr;
printf("*ptr = %d\n", *ptr); // 100
printf("*ptr++ = %d\n", *ptr++); // 100 (use ptr, then advance)
printf("*ptr = %d\n", *ptr); // 200
printf("*++ptr = %d\n", *++ptr); // 300 (advance ptr, then use)
printf("++*ptr = %d\n", ++*ptr); // 301 (increment the value ptr points to)
return 0;
}
Output
*ptr = 100 *ptr++ = 100 *ptr = 200 *++ptr = 300 ++*ptr = 301
Understanding pointer operations with ++:
*ptr++→*(ptr++)— dereference, then advance pointer*++ptr→*(++ptr)— advance pointer, then dereference++*ptr→++(*ptr)— increment the pointed-to value(*ptr)++— use the pointed-to value, then increment it
Common Pitfalls and Undefined Behavior
Multiple modifications in one expression
Example
#include <stdio.h>
int main() {
int i = 5;
// UNDEFINED BEHAVIOR - never do this!
// int result = i++ + ++i; // Which i is modified first? Unknown!
// UNDEFINED BEHAVIOR - don't modify same variable twice
// int result = ++i + i++;
// SAFE: use separate statements
int a = 5, b = 5;
a++; // a = 6
int result = a + (++b); // result = 6 + 6 = 12
printf("Safe result: %d\n", result);
return 0;
}
Output
Safe result: 12
Rule: Never modify a variable more than once between two sequence points. The C standard says this is undefined behavior, meaning the compiler can produce any result.
Confusing in function arguments
Example
#include <stdio.h>
void display(int a, int b) {
printf("a=%d, b=%d\n", a, b);
}
int main() {
int x = 5;
// UNDEFINED: order of argument evaluation is unspecified
// display(x++, x++); // Could be (5,6) or (6,5) or anything
// SAFE: use separate variables
int arg1 = x++; // arg1=5, x=6
int arg2 = x++; // arg2=6, x=7
display(arg1, arg2);
return 0;
}
Output
a=5, b=6
Practical Examples
Digit Counter
Example
#include <stdio.h>
int main() {
int num = 123456;
int digits = 0;
int temp = num;
while (temp != 0) {
temp /= 10;
digits++;
}
printf("Number %d has %d digits\n", num, digits);
return 0;
}
Output
Number 123456 has 6 digits
String Length (Manual)
Example
#include <stdio.h>
int myStrlen(const char *str) {
int len = 0;
while (*str++) { // Use char, then advance pointer
len++;
}
return len;
}
int main() {
char text[] = "Hello, World!";
printf("Length of \"%s\" = %d\n", text, myStrlen(text));
return 0;
}
Output
Length of "Hello, World!" = 13
Array Reversal
Example
#include <stdio.h>
int main() {
int arr[] = {1, 2, 3, 4, 5};
int n = 5;
int left = 0, right = n - 1;
while (left < right) {
int temp = arr[left];
arr[left++] = arr[right];
arr[right--] = temp;
}
printf("Reversed: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
Output
Reversed: 5 4 3 2 1
Comparison Table: Prefix vs Postfix
| Aspect | Prefix (++x) | Postfix (x++) |
|---|---|---|
| When increment happens | Before use in expression | After use in expression |
| Value of expression | New value (after increment) | Old value (before increment) |
| In standalone statement | Same effect | Same effect |
| In for loop update | Same effect | Same effect |
| Performance (in C) | Same | Same |
| Returns | lvalue (in C++) | rvalue |
Interview Questions
Q1: What is the output of int a = 5; printf("%d %d", a++, ++a);?
This is undefined behavior. The C standard does not specify the order in which function arguments are evaluated. The output is unpredictable and varies between compilers. Never write code like this.
Q2: In a for loop, is there any difference between i++ and ++i?
In C, there's no practical difference when used as a standalone statement in the loop's update expression — both increment i by 1 and the expression value is discarded. In C++ with iterators, ++i is preferred because i++ may create a temporary copy.
**Q3: What does *p++ do vs (*p)++?**
*p++ is *(p++) — it dereferences the pointer to get the current value, then advances the pointer to the next element. (*p)++ dereferences the pointer and increments the value at that memory location. The pointer itself doesn't move.
Q4: Why is i = i++ undefined behavior?
Because i is being modified twice in the same expression without a sequence point — once by the assignment i = ... and once by i++. The C standard says modifying a variable more than once between sequence points is undefined behavior.
Q5: Can you use ++ or -- with constants or expressions?
No. These operators require an lvalue — something with a memory location that can be modified. 5++ or (a+b)++ will result in a compilation error. Only variables (or dereferenced pointers) can be incremented/decremented.
Summary
++adds 1 and--subtracts 1 from a variable- Prefix (
++x) increments first, then returns the new value - Postfix (
x++) returns the current value, then increments - As standalone statements, prefix and postfix are identical
- Never modify the same variable twice in one expression — it's undefined behavior
- In for loops,
i++and++iproduce the same result - With pointers,
*p++and++*phave very different meanings - These operators only work on lvalues (variables), not constants or expressions
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Increment and Decrement Operators in C.
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, operators, increment, decrement, increment and decrement operators in c
Related C Programming Topics
Continue learning this concept
OperatorsArithmetic Operators in C ProgrammingLearn all arithmetic operators in C including addition, subtraction, multiplication, division, and modulus. Understand integer division traps, operator precedence, and type casting with practical examples.OperatorsAssignment Operators in C ProgrammingLearn all assignment operators in C including simple assignment, compound assignment operators (+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=). Understand their syntax, behavior, and practical usage.OperatorsBitwise Operators in C ProgrammingComplete guide to bitwise operators in C: AND, OR, XOR, NOT, left shift, and right shift. Learn practical applications like flag manipulation, masking, and power-of-2 operations with examples.OperatorsLogical Operators in C ProgrammingLearn logical operators in C: AND (&&), OR (||), and NOT (!). Understand short-circuit evaluation, truth tables, operator precedence, and practical examples for decision-making.OperatorsRelational Operators in C ProgrammingMaster relational (comparison) operators in C: equal to, not equal, greater than, less than, and their combinations. Learn how they return 0 or 1, common mistakes, and usage in conditions.OperatorsTernary Operator in C ProgrammingLearn the ternary (conditional) operator (?:) in C. Understand syntax, nested ternary expressions, when to use ternary vs if-else, and practical examples for concise conditional logic.