Difference Between ++i and i++ in C

By the end of this page, you will understand how pre-increment (++i) and post-increment (i++) work in C, when they produce different results, and why both are usually equivalent in the increment part of a for loop.

In C, both ++i and i++ increase the value of i by 1, but they differ in when the old or new value is produced as the result of the expression.

• ++i is called pre-increment.
  • It increments i first.
  • Then the expression evaluates to the new value.
• i++ is called post-increment.
  • It evaluates to the current value first.
  • Then i is incremented.

Why this matters

This difference only matters when the increment expression is used as part of a larger expression.

For example:

int i = 5;
int a = ++i; // i becomes 6, a gets 6

int i = 5;
int a = i++; // a gets 5, then i becomes 6

In real C programs, understanding this helps you:

• avoid logic bugs
• read loop code correctly
• avoid undefined or confusing expressions
• write clearer intent when updating counters

In a for loop

Think of i as a number written on a whiteboard.

• ++i means: erase the number, write the bigger number, then show it
• i++ means: show the current number, then erase it and write the bigger number

Example with i = 3:

• ++i gives you 4, and i is now 4
• i++ gives you 3, but i becomes 4 immediately after

In a for loop update section, nobody is looking at the returned value. They only care that the whiteboard number increases. That is why both forms behave the same there.

Core syntax

++i;   // pre-increment
i++;   // post-increment

Both increase i by 1.

Example 1: used alone

int i = 0;
++i;
printf("%d\n", i); // 1

i++;
printf("%d\n", i); // 2

When used by themselves on a line, both simply increment the variable.

Example 2: used in an assignment

int i = 5;
int a = ++i;
printf("i = %d, a = %d\n", i, a); // i = 6, a = 6

++i increments first, so both i and a become 6.

int i = 5;
int a = i++;
printf(, i, a); 

Consider this code:

int i = 2;
int x = i++;
int y = ++i;

Step by step:

1. i starts as 2.
2. int x = i++;
   • x gets the current value of i, which is 2
   • then i is incremented to 3
3. int y = ++i;
   • i is incremented first, from 3 to 4
   • then y gets that new value, which is 4

Final values:

i == 4
x == 2
y == 4

Loop counters

The most common use is counting iterations:

for (int i = 0; i < count; i++) {
    // process item i
}

Array traversal

Increment operators are often used while walking through arrays:

for (int i = 0; i < size; i++) {
    sum += numbers[i];
}

Pointer movement

In C, incrementing pointers is very common:

char *p = buffer;
p++; // move to next character

When expression value matters, choosing pre- or post-increment becomes important.

Reading tokens or characters

char c = *p++;

This means:

• read the character currently pointed to by p
• then move p to the next position

That is different from:

char c = *++p;

In real C codebases, developers use ++ in a few common ways.

1. Loop updates

for (int i = 0; i < n; i++)

or

for (int i = 0; i < n; ++i)

In C, both are fine in loop updates because the result is discarded.

2. Guarded processing loops

for (int i = 0; i < count; i++) {
    if (items[i] == NULL) {
        continue;
    }
    process(items[i]);
}

The increment is separate from the logic, which keeps the loop readable.

3. Pointer-based parsing

while (*p != '\0') {
    putchar(*p);
    p++;
}

Or more compactly:

while (*p) {
    putchar(*p++);
}

This pattern is common, but beginners should be careful because expression order matters more.

1. Thinking they are always identical

They are not always identical.

int i = 5;
int a = ++i; // a = 6

int i = 5;
int a = i++; // a = 5

If the value is used, the difference matters.

2. Writing overly complex expressions

Broken or confusing example:

int i = 1;
int x = i++ + ++i;

This is hard to reason about and may lead to undefined behavior in C because i is modified more than once without a proper sequencing relationship.

Avoid this completely.

Safer version:

int i = 1;
int x = i;
i++;
++i;
x = x + i;

Or better, rewrite the logic clearly.

3. Assuming ++i is always faster in C

In C, especially for built-in integer types, modern compilers usually generate equally efficient code for loop counters.

++i vs i++ in common situations

Quick rules

• ++i = increment first, then use the value
• i++ = use the value first, then increment
• If used alone on a line, both usually have the same effect
• In a for loop update section, both are usually equivalent in C

Examples

int i = 3;
int a = ++i; // i = 4, a = 4

int i = 3;
int a = i++; // a = 3, i = 4

Loop usage

for (int i = 0; i < 10; i++)

for (int i = 0; i < 10; ++i)

Both are acceptable in C.

Safe advice

• Use whichever is clearer in loop updates
• Do not modify the same variable multiple times in one expression
• Keep increment expressions simple

Pointer reminder

Is ++i faster than i++ in C?

Usually not in any meaningful way for basic integer variables. Modern C compilers typically optimize both forms well.

Which should I use in a for loop in C?

Either i++ or ++i is fine in the increment section of a for loop, because the expression result is not used.

Do ++i and i++ always give the same result?

No. They both increment the variable, but the value produced by the expression is different.

When does the difference actually matter?

It matters when the increment expression is part of a larger expression, such as an assignment, function argument, or pointer expression.

Is i = i + 1 the same as i++?

As an update, yes, both increase i by 1. But i++ also has a specific expression result: it returns the old value before incrementing.

Why do some programmers prefer ++i in loops?

Sometimes it is a style habit, and in some other languages or types it may matter more. In plain C integer loops, there is usually no practical difference.

• for loops — increment operators are commonly used in the update section of loops.
• while loops — loop counters are often managed manually with increment expressions.
• operators in C — ++ is part of C's operator system and interacts with expression evaluation.
• expressions and statements — understanding whether a value is produced or ignored is key here.
• undefined behavior — complex increment expressions can cause serious bugs in C.
• pointers in C — pre-increment and post-increment are often used with pointer traversal.
• operator precedence — expressions like *p++ depend on precedence rules.
• assignment in C — the difference between old and new values often appears in assignments.