Lesson 4 · ~15 minutes · ties to mission: read and write C confidently

Unpacking `p++ = q++`

You saw this compressed idiom in lesson 2 and were told to keep writing the three-line version for now. Now it's time to own it — by seeing exactly what the compiler does.

The three-line version you already know

*p = *q;     // copy: read q's target, write to p's target
p++;         // advance the write head
q++;         // advance the read head



This is the two-pointer lockstep from lesson 2 — clear, explicit, nothing hidden. Every grown-up C programmer compresses it to one line. Let's see why that works.

The one operator you need: postfix ++

Postfix ++ does two things, and the order is the whole lesson:


  Step What happens
  
    1. Yield The expression produces the current value (before incrementing).
    2. Side effect The variable is incremented after the value is yielded.
  


So p++ means: "give me p's current value, then add 1 to p." It's a post-increment — use, then change.


  Contrast: prefix ++p
  Prefix ++p increments first, then yields the new value. Change, then use. We won't need it in this lesson, but knowing it exists is important — it's the other side of the coin.


Now layer in the * (dereference) operator

You know *p means "the thing p points at." The question is: in *p++, which binds tighter — * or ++?


  Expression Operator precedence What it means
  
    *p++ ++ (postfix) binds tighter than * *(p++) — dereference the old value of p, then increment p
    (*p)++ Explicit grouping Dereference p, then increment the value at that address
    *++p ++ (prefix) binds tighter than * Increment p first, then dereference the new address
  



  The key insight
  *p++ reads from p's current target, then moves p forward. The data you get is from the old position. The pointer has already moved on by the time the expression is done. That's exactly the lockstep move — in a single expression.


Unroll the full line: *p++ = *q++

The assignment = evaluates right-to-left. The compiler sees:


*p++ = *q++;

  ▼ step-by-step
// Right side: *q++
1. Yield current value of q  →  say, address 0x1000
2. Dereference that address  →  say, character 'W'
3. Side effect: q becomes 0x1001

// Left side: *p++
4. Yield current value of p  →  say, address 0x2005
5. Dereference that address  →  slot at 0x2005
6. Side effect: p becomes 0x2006

// Assignment
7. Write the right-side result ('W') into the left-side slot (0x2005)


Seven steps, one line. And it produces exactly the same result as the three-line version:

*p = *q;     // copy 'W' from 0x1000 to 0x2005
p++;         // p → 0x2006
q++;         // q → 0x1001


The memory diagram — same as lesson 2

Nothing has changed about what happens in memory. *p++ = *q++ is just a shorthand for the lockstep copy you already understand. Here's one iteration:

dest:   H  e  l  l  o '\0'  ?   ?   ?  ...
                     ↑
                     p

str2:   W  o  r  l  d  '\0'
        ↑
        q

After one iteration of *p++ = *q++:

dest:   H  e  l  l  o  W   ?   ?  ...
                          ↑
                          p  (advanced)

str2:   W  o  r  l  d  '\0'
            ↑
            q  (advanced)

Same bytes moved, same pointers advanced. Just fewer keystrokes.

The six forms — at a glance

Because combining * and ++ creates confusion, here's the complete set. Don't memorize this — derive each one from the rule "postfix ++ binds tighter than *." The table is for later reference.


  Expression Expanded Effect
  
    *p++ *(p++) Read value at p, then advance p. ← this is the one you use
    *++p *(++p) Advance p first, then read new value.
    (*p)++ — Read value at p, increment the value (not the pointer).
    *--p *(--p) Step p back, then read new value. ← reverse copy
    *p-- *(p--) Read value at p, then step p back.
    ++*p ++(*p) Increment the value at p, yield new value.
  


When to use the compact form


  Your progression
  Phase 1 (where you were): write *p = *q; p++; q++; — three lines, explicit, no ambiguity.

  Phase 2 (where you are now): understand *p++ = *q++ because you've seen it unrolled. Use it when reading other people's code.

  Phase 3 (where you're heading): start using *p++ = *q++ in your own code, when the three-line version feels tedious. You'll know you're ready when you can read *p++ = *q++ and instantly see "copy, advance both" without mentally unrolling it.


Check yourself


  ① What does *p++ evaluate to?
  Show answer
  The value at p's current address (before the increment). It dereferences the old value, then moves p forward as a side effect. So *p++ yields a char (or whatever p points at), not a pointer.
  



  ② What's the difference between *p++ and (*p)++?
  Show answer
  *p++ (i.e. *(p++)) advances the pointer. (*p)++ advances the value the pointer targets. 


  Example: if p points at an int holding 42: *p++ yields 42 and moves p to the next int. (*p)++ yields 42 and changes the value at the current address to 43, without moving p.
  



  ③ Rewrite *p++ = *q++ using prefix increment instead.
  Show answer
  You'd need: *p = *q; ++p; ++q; — you can't directly replace *p++ with *++p because the semantics would change (prefix increments first, so you'd skip the first element). The compact *p++ = *q++ works precisely because both are postfix — they yield the old position, then advance.
  



  ④ In while (*p++ = *q++); — what's the loop condition actually testing?
  Show answer
  The value assigned — the character copied from *q. The loop continues while that character is non-zero (i.e. not '\0'). It stops when *q yields '\0' (which is 0), which also copies that '\0' into *p before terminating. This is actually the classic one-liner strcpy implementation — it copies the terminator and stops, all in the condition. Elegant, but don't write this in production — it's a readability trap.
  



  🛠️ Hands-on — rewrite your mystrcat using the compact form
  Take your working mystrcat function from the lesson 2 hands-on and create a second version:
  
    Copy the function. Name it mystrcat_compact.
    Replace the three-line lockstep in Act 2 with *p++ = *q++;
    Keep Acts 1 and 3 in expanded form (don't compress those yet — one thing at a time).
    Compile, run, and verify it produces the same output.
    Once it works: try compressing Act 1 into while (*p) p++;. Does it still work? (Yes — *p is non-zero until '\0', so this skips the explicit != '\0' test.)
    Compare: read both versions side by side. Which is easier to understand at a glance? Both are correct — the question is what your eyes can parse without effort.
  



  What you can now do
  Read *p++ = *q++ and instantly know it means "copy, advance both." You can mentally unroll it to the three-line version. You know postfix ++ binds tighter than *, and you know the difference between *p++ and (*p)++. You've also seen the classic one-liner strcpy trick — even if you shouldn't write it yourself yet.



  Questions? Ask your agent.
  Anything murky — "what about *p++ + *q++?", "is there a performance difference?", "why does the one-liner strcpy work?" — type it and we'll dig in.



  Sources & further reading

  · cppreference: C operator precedence — the full table. Postfix ++ is precedence 2 (second-highest); dereference * is precedence 3.

  · comp.lang.c FAQ — Pre vs Post increment

  · Beej's Guide to C Programming — pointers chapter, covers the *p++ idiom.

  · Companion cheat sheet · Lesson 2: strcat unrolled · Lesson 3: the const matrix

Step	What happens
1. Yield	The expression produces the current value (before incrementing).
2. Side effect	The variable is incremented after the value is yielded.

Expression	Operator precedence	What it means
`*p++`	`++` (postfix) binds tighter than `*`	`(p++)` — dereference the old* value of `p`, then increment `p`
`(*p)++`	Explicit grouping	Dereference `p`, then increment the value at that address
`*++p`	`++` (prefix) binds tighter than `*`	Increment `p` first, then dereference the new address

Expression	Expanded	Effect
`*p++`	`*(p++)`	Read value at `p`, then advance `p`. ← this is the one you use
`*++p`	`*(++p)`	Advance `p` first, then read new value.
`(*p)++`	—	Read value at `p`, increment the value (not the pointer).
`*--p`	`*(--p)`	Step `p` back, then read new value. ← reverse copy
`*p--`	`*(p--)`	Read value at `p`, then step `p` back.
`++*p`	`++(*p)`	Increment the value at `p`, yield new value.

Unpacking `p++ = q++`

The three-line version you already know

The one operator you need: postfix `++`

Now layer in the `*` (dereference) operator

Unroll the full line: `p++ = q++`

The memory diagram — same as lesson 2

The six forms — at a glance

When to use the compact form

Check yourself

① What does `*p++` evaluate to?

② What's the difference between `p++` and `(p)++`?

③ Rewrite `p++ = q++` using prefix increment instead.

④ In `while (p++ = q++);` — what's the loop condition actually testing?

🛠️ Hands-on — rewrite your `mystrcat` using the compact form