It was the middle of July and How hard could ++ and — possibly be? That illusion was shattered within twenty minutes. . The fan above us spun lazily, indifferent to the collective anxiety in the air. My second-year class was knee-deep in C programming, and on that particular afternoon, we were scheduled to tackle what most students assumed would be a “light topic”—increment and decrement operators. 

The Day ++ and — Became a Villain 

A student named Aditya raised his hand. He was one of those quiet but observant ones the kind who never spoke unless something genuinely bugged him. “Sir,” he said cautiously, “I don’t get why i = i++ doesn’t increment the value.” 

A few chuckled. But I didn’t. This was the exact kind of trap that snags even seasoned coders. 

“Okay,” I said, “let’s break this down together. Forget the code for a second. Imagine you’re at a coffee shop.” 

That got their attention. 

A Coffee Shop Metaphor 

I drew on the board: 

int i = 5; 
i = i++; 
printf(“%d”, i); 
 

Now, I turned to the class. 

“Let’s say you walk into a coffee shop at table number 5. You order coffee. The waiter comes to your table with the bill and says, ‘You’re number 5, right? Here’s your bill.’ But meanwhile, in his notebook, he quietly writes down, ‘Okay, this guy is now number 6 for next time.’ 

But today’s bill? It’s still for number 5. 

That’s what happens with i++. It uses the current value first and then increments it. But since you stored the result back into i, it just overwrote the future.” 

I looked around. Heads nodded. Some even smiled. Riya, who had been scowling at her screen earlier, whispered, “So i = i++ is like paying yesterday’s bill for today’s coffee.” 

“Exactly,” I said. “And the coffee shop doesn’t give refunds.” 

Prefix vs Postfix: The Drama Twins 

To really drive it home, I asked them to consider two friends: Preeti Prefix and Pawan Postfix. 

• Preeti (++i): does things before she moves on. 

• Pawan (i++): does things after the current task. 

I wrote: 

int a = 5; 
int b = ++a;  // Preeti: increments first, then uses it 
// a = 6, b = 6 
 

Versus: 

int a = 5; 
int b = a++;  // Pawan: uses value, then increments 
// a = 6, b = 5 
 

Pawan and Preeti became inside jokes for the rest of the semester. 

Behind the Scenes: How the Compiler Thinks 

Many of my students imagined the compiler just blindly incrementing or decrementing. But when I showed them the underlying assembly-like logic, it changed how they viewed the simple-looking ++: 

i++; 
 

This doesn’t just mean “increase i.” It means: 

1. Create a temporary copy of i 

2. Increment the original i 

3. Use the temporary copy in the current expression if it’s postfix 

Whereas with: 

++i; 
 

The value of i is incremented immediately, and the new value is used for the rest of the expression. 

Subtle? Absolutely. But in C, these subtleties matter. Especially inside loops or function calls. 

Loop Trouble: When ++ Misbehaves 

The real chaos broke loose when we hit this loop: 

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

Notice the sneaky semicolon? One of my students, Pranav, had copied this from an online example. “Sir, nothing prints inside the loop!” 

I smiled. “That’s because the loop already ran. The semicolon turned it into an empty loop body. You just incremented i five times doing… nothing.” 

Then we explored another gotcha: 

while (i++ < 5) 
   printf(“%d\n”, i); 
 

What do you think prints? Most students guessed 1 to 5. But C had other ideas. 

On the board, I walked them through the dry run. The first comparison happens with the old value of i, then it’s incremented meaning you end up printing from 2 to 6. 

“Ahhh,” Riya groaned. “Postfix strikes again.” 

Decrement Drama 

A week later, I ran a surprise quiz. One question asked: 

int x = 3; 
printf(“%d\n”, –x – x–); 
 

The answers ranged from 0 to -1 to 2. Only two students got it right. 

Let’s walk through it: 

1. –x makes x go from 3 to 2. Value used: 2 

2. x– uses the current x (which is now 2), and then decrements it to 1. 

3. So: 2 – 2 = 0 

Simple? Yes—if you respect the order of evaluation and side effects. But C doesn’t guarantee which side is evaluated first in such expressions, so never write such code in real projects. 

“I get it now,” Aditya said. “–x – x– is legal but criminal.” 

Exactly. 

Lessons Beyond Code 

After class, a few students stayed back. “Sir, I always thought increment/decrement was just shorthand. Like lazy math.” 

I nodded. “It is, sometimes. But in C, even lazy math has rules. You don’t just throw ++ or — around and hope for the best.” 

That day, increment and decrement operators weren’t just syntax. They became symbols of how small details in C can make or break logic. 

From subtle bugs to sneaky loop mistakes, my students realized that understanding the behavior behind these two-character operators is essential for writing safe, predictable code. 

Quick Recap and Best Practices 

1. Postfix (i++): Use the current value, then increment. 

2. Prefix (++i): Increment first, then use the updated value. 

3. Avoid using both increment and decrement in the same expression—side effects can lead to undefined behavior. 

4. Beware of loops and semicolons—they can make your logic vanish. 

5. Dry-run your code. Even if it’s two lines, walk through it step by step. 

Want to see how such small operators can hold such big impact? Just give students a loop and let ++ or — loose. You’ll see logic fly or crash—and the debugging journey that follows is where real learning begins.