What is the difference between post and pre increment unary operators in c with example?

Answer 1

They both increment the variable. But the value returned by the pre-increment operator is the value of the variable after it has been incremented, while the value returned by the post-increment operator is the value before it has been incremented.

For example:

int a = 1;

int b = ++a;

// Now a is 2 and b is also 2.

int a = 1;

int b = a++;

// Now a is 2 but b is 1.

Answer 2

The post and pre increment operators work like this:

POST: $i++;

PRE: ++$i;

The difference is NOT apparent in most statements. For instance, the above two statements do the same thing- increase $i by 1.

But when combined with other statements like echo, or comparisions, then the difference comes to light.

e.g.

$i=1;

echo $i++;

prints 1.

$i=1;

echo ++$i;

prints 2.

In the first case, $i is first printed (or compared) and then incremented.

In the second case, $i is first incremented, then printed (or compared).

Answer 3

Pre increment means that if you have for instance a loop:

{

...

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

{

// the index i before the first iteration equals 1

...

// the index i after the first iteration equals 2

}

}

Post increment

{

...

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

{

// the index i after before the iteration equals 2

...

// the index i after the first iteration equals 3

}

}

Answer 4

Both pre-increment and post-increment ultimately increment the operand. The difference is that during the evaluation of the expression, the results of the intermediate expression for the pre-increment case uses the already incremented value, while the post-increment case uses the non incremented value. An example.

int a = 2;

int b = 5;

int c = a ++ * b;

In this case, a will have a value of 3, and c will have a value of 10.

If, on the other hand, you said

int c = ++ a * b;

then c would have a value of 15, while a would still have a value of 3.

Answer 5

The pre-increment operator (++identifier) increments the identifier before making its value available to any surrounding expression. The post-increment operator (identifier++) increments the identifier after making its value available to any surrounding expression.

int a = 2;

int b = 3;

int c = a++ + b;

the result is that a 6

Used alone, the two versions have the same effect, however, the pre-increment version is more efficient because the compiler does not need to generate an interim copy of the object. This can be important if the object is complex, such as a class, and if the expression is used within a tight loop.

Answer 6

The execution sequence/timing.

For pre-decrement, the decremental happens BEFORE the actual operation (passing as an argument to another function, for example).

Post-decrement, the decremental (-1) happens AFTER the actual operation.

The confusion parts is the stand-alone version. They are "equivalent":

n--;

--n;

But:

int k = 10;

Call_FUN(k--); // k is 10, passed to CALL_FUN, but after CALL_FUN finished, K is 9

Call_ARG(--k); // K is 9 from above, substract 1 first, becomes 8, then passed 8 to Call_ARG()

Answer 7

Consider the following declaration:

class MyClass

{

public:

MyClass:x( 0 ){}

private:

int x;

public:

MyClass& operator++() //Prefix increment operator (e.g., ++MyObject).

{

x = x + 1; // perform the increment.

return( *this ); // return by reference.

}

MyClass operator++(int) //Postfix increment operator (e.g., MyObject++).

{

MyClass temp = *this; // temporary copy.

x = x + 1; // preform the increment.

return( temp ); // return the copy by value.

}

};

Note that the postfix increment operator creates and returns a temporary value, which calls the class copy constructor. If this temporary value is not actually needed by the caller, then there is no point in copying the current value. This applies to all types, including primitives:

for( int x = 0; x < 10; ++x ){} // preferred method.

for( int y = 0; y < 10; y++ ){} // creates temporary variables that are never actually used.

For primitive types, the difference in performance is negligible, but for classes it is vital that you avoid creating copies unnecessarily. If you get into the habit of using the prefix increment operator on all your primitives, the habit will extend to all your classes. Studies have shown that people who always use the postfix increment operator on primitives tend to do the same with their classes -- which can heavily impact on performance when those classes are large and complex.

Answer 8

The difference is when the variable is incremented. Here is a simple example:

b = ++a; //Here, "a" is incremented, then the value is copied to "b".

b = a++; //Here, the value of "a" is FIRST copied to "b", then "a" is incremented.

Answer 9

An example might help:

int a, b;

a= 2;

b= a++;

/* now a=3, b=2 */

a= 2;

b= ++a;

/* now a=3, b=3 */