Cases where to use Pre-Increment or Post-Increment Operators

Question

Reading a couple of questions about Post-Increment and Pre-Increment I am in need of trying to explain a new programmer in what cases I would actually need one or the other. In what type of scenarios one would apply a Post-Increment Operator and in what it is better to apply a Pre-Increment one.

This is to teach case studies where, in a particular code, one would need to apply one or the other in order to obtain specific values for certain tasks.

Answer 1

The short answer is: You never need them!

The long answer is that the instruction sets of early micro-computers had features like that. Upon reading of a memory cell, you could post-increment or pre-decrement that cell when reading it. Such machine level features inspired the predecessors of C, from whence it found its way even into more recent languages.

To understand this, one must remember that RAM was extremely scarce in those days. When you have 64k addressable RAM for your program, you'll find it worth it to write very compact code. The machine architectures of those days reflected this need by providing extremely powerful instructions. Hence you could express code like:

s = s + a[j]
j = j + 1

with just one instruction, given that s and j were in a register.

Thus we have language features in C that allowed the compiler without much effort to generate efficient code line:

register int s = 0;           // clr r5
s += a[j++];                  // mov j+, r6   move j to r6 and increment j after
                              // add r5,a[r6]

The same goes for the short-cut operations like +=, -=, *= etc.

They are

1. A way to save typing
2. A help for a compiler that had to fit in small RAM, and couldn't afford much optimizations

For example,

a[i] *= 5

which is short for

a[i] = a[i] * 5

in effect saves the compiler some form of common subexpression analysis.

And yet, all that language features, can always be replaced by equivalent, maybe a bit longer code that doesn't use them. Modern compilers should translate them to efficient code, just like the shorter forms.

So the bottom line and answer to your question: you don't need to look for cases where one needs to apply those operators. Such cases simply do not exits.

Answer 2

Well, some people like Douglas Crockford are against using those operators because they can lead to unexpected behaviors by hiding the final result from the untrained eye.

But, since I'm using JSHint, let's share an example here:

http://jsfiddle.net/coma/EB72c/

var List = function(values) {

    this.index = 0;
    this.values = values;
};

List.prototype.next = function() {

    return this.values[++this.index];
};

List.prototype.prev = function() {

    return this.values[--this.index];
};

List.prototype.current = function() {

    return this.values[this.index];
};

List.prototype.prefix = function(prefixes) {

    var i;

    for (i = 0; i < this.values.length; i++) {

        this.values[i] = prefixes[i] + this.values[i];
    }
};

var animals = new List(['dog', 'cat', 'parrot']);

console.log('current', animals.current());
console.log('next', animals.next());
console.log('next', animals.next());
console.log('current', animals.current());
console.log('prev', animals.prev());
console.log('prev', animals.prev());

animals.prefix(['Snoopy the ', 'Gartfield the ', 'A ']);

console.log('current', animals.current());

Answer 3

As others have said, you never "need" either flavor of the ++ and -- operators. Then again, there are a lot of features of languages that you never "need" but that are useful in clearly expressing the intent of the code. You don't need an assignment that returns a value either, or unary negation since you can always write (0-x)... heck, if you push that to the limit you don't need C at all since you can always write in assembler, and you don't need assembler since you can always just set the bits to construct the instructions by hand...

(Cue Frank Hayes' song, When I Was A Boy. And get off my lawn, you kids!)

So the real answer here is to use the increment and decrement operators where they make sense stylistically -- where the value being manipulated is in some sense a counter and where it makes sense to advance the count "in passing". Loop control is one obvious place where people expect to see increment/decrement and where it reads more clearly than the alternatives. And there are many C idioms which have almost become meta-statements in the language as it is actually used -- the classic one-liner version of strcpy(), for example -- and which an experienced C programmer will recognize at a glance and be able to recreate at need; many of those do take advantage of increment/decrement as side effect.

Unfortunately, "where it makes sense stylistically" is not a simple rule to teach. As with any other aspect of coding style, it really needs to come from exposure to other folks' code and from an understanding of how "native speakers" of the programming language think about the code.

That isn't a very satisfying answer, I know. But I don't think a better one exists.

Answer 4

Usually, it just depends on what you need in your specific case. If you need the result of the operation, it's just a question of whether you need the value of the variable before or after incrementing / decrementing. So use the one which makes the code more clear to understand.

In some languages like C++ it is considered good practice to use the pre-increment / pre-decrement operators if you don't need the value, since the post operators need to store the previous value in a temporary during the operation, therefore they require more instructions (additional copy) and can cause performance issues for complex types.

I'm no C expert but I don't think it really matters which you use in C, since there are no increment / decrement operators for large structs.