Pre Increment and Post Increment Operator in C

Last Updated on May 22, 2023 by Prepbytes

In C programming, there are two commonly used increment operators: the pre-increment operator and the post-increment operator. These operators are used to increase the value of a variable by one.

The pre-increment operator (++x) increments the value of the variable before using it in an expression. It first adds one to the variable and then returns the updated value. For example, if the variable x is initially 5, using the pre-increment operator like ++x would increase its value to 6.

On the other hand, the post-increment operator (x++) increments the value of the variable after using it in an expression. It returns the original value of the variable and then adds one to it. Using the post-increment operator on the variable x, with an initial value of 5, would return 5 and then increase the value of x to 6.

What are Pre-Increment and Post-Increment Operators?

Whether a variable is a float, an integer, or a pointer, the operator can raise its value in the C programming language. The address that the pointer is pointing at will rise in the latter situation.

As their names imply, there are some distinctions between the two operators, but overall, they both do an excellent job at adding one to the number. We shall examine each of the examples of various data types listed in this article on which these two operations operate and examine the fundamental distinctions between pre increment and post increment in C.

Pre-Increment Operator

Before the value is utilized in a specific statement, it adds one to the value. To produce a legitimate increment statement, such as ++i where i is the variable name upon which the pre-increment operation is conducted so that no other operations are performed before the pre-increment, it is indicated by the notation ++, which must be inserted before the variable name.

Now let’s take an example of how the pre increment operator works:-

#include <stdio.h>

int main() {
  int x = 7;
  int y = ++x;

  printf("x is %d\n", x);
  printf("y is %d\n", y);

  return 0;
}

Output:

x is 8
y is 8

Explanation of the above code:
The x and y integer variables are declared in the following program, and x is initialized to 7. With the equation ++x, the value of x is increased by 1 and the new value is returned, which is then assigned to y. As a result, y is given the value 8. Then, using printf, the program outputs the values of x and y to the terminal. The program ends by returning 0 at the conclusion.

Post-Increment Operator

Post increment operates similarly to pre-increment in that it increases a variable’s value by one, but only after the variable is used in an expression. It is indicated by adding a plus sign (++) to the end of the variable name, as in i++, where i is the name of our variable. As a result, when performing post increment, the variable’s value is first used and then increased.

Let’s Take an example to understand better the working of the post increment operator:-

#include <stdio.h>

int main() {
  int x = 7;
  int y = x++;

  printf("x is %d\n", x);
  printf("y is %d\n", y);

  return 0;
}

Output:

x is 8
y is 7

Explanation of the above code:
The x and y integer variables are declared in the following programme, and x is initialized to 7. With the equation ++x, the value of x is increased by 1 and the new value is returned, which is then assigned to y. As a result, y is given the value 8. Then, using printf, the programme outputs the values of x and y to the terminal. The programme ends by returning 0 at the conclusion.

Special Case of Post Increment Operator

For a case when a post-incremented value is assigned to the same variable, it would not increment and remain the same for such a case.

Syntax of post increment operator:

i = i++

Code Implementation:

#include <stdio.h>

int main()
{
    int x = 10;
    printf("x before post-increment: %d\n", x);
    x = x++;
    printf("x after post-increment: %d\n", x);
    return 0;
}

Explanation of the above code:
In the example above, it can come as a surprise because we might anticipate that the value of x would be increased by 1. The post-increment operator, on the other hand, increments x before returning the value it had before being increased. The value of x after the assignment is the same as before because in this instance, the value of x is assigned to itself before it is incremented.

Compatibility of Increment Operator

Now that we are able to differentiate between pre increment and post increment in c, lets look at where we can move to use them and where we need to avoid them so that we do not stumble across any errors.

Pre increment and post increment in C can be used either with integer or float or pointers but it would be using the address to increment. Let’s look at the example for each.

1. Integer

int x = 5;
x++;
print("The value of x is now %d\n", x);

Output:

The value of x is now 6

Explanation:
In the above code, the operator is applied to a variable x, that is an integer as declared and initialized. Increment operation performed in line 2 with printing the value in line 3

Note:
It can be used with character variables as characters are represented as ASCII values in C. Such as the value of ‘a’ being 97.

2. Float

float x = 5.5;
x++;
print("The value of x is now %d\n", x);

Output:

The value of x is now 6.5

Explanation:
In the above code, the operator is applied to a variable x, which is a float as declared and initialized. Increment operation performed in line 2 with printing the value in line 3

3. Pointer

int arr[3] = {1, 2, 3};
int* ptr = arr;
ptr++;
printf("The value of the second element is %d\n", *ptr);

Output:

The value of the second element is 2

Explanation:
In the above code, an array is initialized with elements 1,2 and 3. A pointer named ptr is assigned to the first element of the array. On the next line, the pointer is incremented to the next element of the array. So the pointer point to the second element which is 2.

Associativity of the Operators

Although pre-increment and post-increment in C are identical in terms of how they work, they sometimes diverge in other respects, such as associativity.
The pre increment (++x) has a lower precedence than the post increment (x++). Additionally, associativity differs for the two operators. The pre-increment (++x) has a right-to-left associativity, meaning that anything that has the same precedence and is on the right will be executed first. On the other hand, the post increment (++x) associativity is left to right.

Conclusion
The pre-increment operator (++x) increments the value of a variable before its current value is used in the expression. This operator directly modifies the variable, leading to faster execution in some cases. It is commonly used when the updated value of the variable is required immediately after the increment operation.

On the other hand, the post-increment operator (x++) increments the value of a variable after its current value is used in the expression. This operator creates a temporary copy of the variable’s original value before incrementing it. It is often used when the original value of the variable needs to be used in the expression before it is incremented.

Care must be taken when using these operators within complex expressions, as their placement can impact the result. Mixing these operators with other arithmetic or assignment operators can lead to unexpected outcomes and make the code harder to read and understand. Therefore, it is important to use parentheses or break down complex expressions to ensure clarity and avoid potential bugs.

Frequently Asked Questions

Q1. Can pre-increment and post-increment operators be used with any variable type in C?
Ans. Yes, both operators can be used with integer variables, floating-point variables, and pointers in C.

Q2. How are pre-increment and post-increment operators useful in programming?
Ans. Increment operators are commonly used in loops, conditionals, and other programming constructs where you need to manipulate or track the value of a variable. They provide a concise and convenient way to increment a variable by one.

Q3. What happens when the pre-increment or post-increment operator is used with a constant or an expression?
Ans. The pre-increment and post-increment operators can only be used with variables, not constants or expressions. Trying to use them with a constant or an expression will result in a compilation error.

Q4. Are there any performance differences between pre-increment and post-increment operators?
Ans. In most cases, modern compilers optimize pre-increment and post-increment operators to produce the same result. However, it is generally recommended to use the pre-increment operator (++x) when the value of the variable itself is not needed in the expression, as it may result in slightly better performance.

Q5. Can pre-increment and post-increment operators be used multiple times in a single statement?
Ans. Yes, you can use the increment operators multiple times within a single statement, as long as the behavior is consistent with the operator being used. For example, x = ++y++ is not valid, but x = ++y; z = y++; is valid.

Q6. Can pre-increment and post-increment operators be used in function arguments?
Ans. Yes, pre-increment and post-increment operators can be used as function arguments. However, it is important to note that the order of evaluation of function arguments is not specified in C, so it is generally recommended to avoid using increment operators within function arguments to ensure predictable behavior.

Q7. Are there any other similar operators in C?
Ans. In addition to the pre-increment (++x) and post-increment (x++) operators, C also provides pre-decrement (–x) and post-decrement (x–) operators, which decrease the value of a variable by one. They follow a similar logic to the increment operators but perform the opposite operation.