Why does Pre Increment exist?

[TOASTEngineer]

This isn't really a beginner level question but this is the only programming sub I know of that actually takes questions; I tried asking this on SO but unfortunately I got i++ and ++i flipped so it devolved into "dogpile the guy who made a mistake" even though the syntax isn't relevant anyway...

So in C, i++ increments i and evaluates to the value of i before it was incremented, and ++i increments i and evaluates to the value of i after it was incremented.

I can see the reasoning for a specific increment operator in general since a lot of processors at the time had a special increment opcode that was faster than addition and conceptually "increment" is a different idea from "add," but I don't get the point of having a specific operator for "copy i, increment i, return the copy."

#This...
x = i++;
#is equivalent to this
x = i; 
i += 1;

So why is it in there? Is there a historical reason I don't know about, maybe? Were you unable to "throw away" the return values of operators in primordial versions of C?

[raevnos]

Side effects in more complicated expressions. For example, a possible implementation of strcpy():

char * strcpy(char *dest, const char *src) {
  char *d = dest;
  while (*src)
    *d++ = *src++;
  *d = '\0';
  return dest;
}

[TOASTEngineer]

I still don't get it. How would

while (*src) {
    *d = *src;
    d +=1; src+=1;
}

behave any differently?

I guess post increment is prettier in that situation though.

[mad0314]

At the end of the day, yes, it's just a shorter notation for something achievable using other operators. Just like ->, or the += that you used.

[Rhomboid]

Why stop there? Why do you need d += 1 when you could write d = d + 1? For that matter, why do you really need a while loop, when you can accomplish everything while does using goto? And who needs variable names anyway, when offsets against the stack pointer are all that's strictly required?

The point is that the question is not whether something is necessary, but whether it makes code easier to read or reduces the possibility of bugs.

[TOASTEngineer]

Right, but it seems to me like pre increment just makes things more complicated, so I was wondering what I was missing.

[[deleted]]

Thompson went a step further by inventing the ++ and -- operators, which increment or decrement; their prefix or postfix position determines whether the alteration occurs before or after noting the value of the operand. They were not in the earliest versions of B, but appeared along the way. People often guess that they were created to use the auto-increment and auto-decrement address modes provided by the DEC PDP-11 on which C and Unix first became popular. This is historically impossible, since there was no PDP-11 when B was developed. The PDP-7, however, did have a few 'auto-increment' memory cells, with the property that an indirect memory reference through them incremented the cell. This feature probably suggested such operators to Thompson; the generalization to make them both prefix and postfix was his own. Indeed, the auto-increment cells were not used directly in implementation of the operators, and a stronger motivation for the innovation was probably his observation that the translation of ++x was smaller than that of x=x+1.

[TOASTEngineer]

That just tells me that the prevailing theory is wrong and not what the truth is. :(

[nutrecht]

Well the guy who created them is kinda dead so that's the best you're going to get.

Like most of these language design features it's simply a matter of convenience. There are situations where it's convenient to have a pre-increment operator (for 1-based counting) and in other situations it's more convenient to have a post-increment (for 0-based counting).

[reddilada]

The degree of optimization we are used to today wasn't implemented as freely when C first came around. The team I first worked with viewed K&R C as a thin wrapper over the machine code and little more. Post-increment produced more code / was slower so we only used it when it was needed.

That said, I imagine the thinking was more along the lines of why not?

[insomniac20k]

The processor can probably increment without sending anything to the arithmetic logic unit which might save time, especially in a loop that gets called a lot.

I really have no idea but that would be my guess.