← Back to Knowledge Base← Previous questionNext question →
ProgrammingC Developer

Describe the differences between the increment operations (i++) and (++i) in the C language. What is their semantics, when should each variant be used, and what are the dangers in complex expressions?

Pass interviews with Hintsage AI assistant

Answer

In the C language, the postfix (i++) and prefix (++i) increment operations increase the value of the variable by 1, but the returned value differs:

  • i++ (postfix): first returns the current value, then increases it.
  • ++i (prefix): first increases the value, then returns the new value.

Example:

int i = 5;
int a = i++;
// a == 5, i == 6

int j = 5;
int b = ++j;
// b == 6, j == 6

In simple expressions, the difference is insignificant, but in complex ones (for example, with multiple increments at once), undefined behavior may occur.

Trick question

What value will variable a have after executing the expression int a = i++ + ++i; if i = 1?

Answer:

The result depends on the order of operand evaluation, which is not guaranteed by the standard, and leads to undefined behavior because variable i is modified more than once between sequential uses of its value. This should not be done!

Example of such code:

int i = 1;
int a = i++ + ++i; // undefined behavior! Do not use this way!

Examples of real errors due to lack of knowledge about the subtleties of the topic

Story

In a large project, calculating the index in an array was done as arr[i++] = getValue(++i); — the developer wanted to preserve the old value while simultaneously obtaining the new one. Behavior varied across different compilers: sometimes one value overwrote the other, and sometimes the program crashed. The reason was the invalid multiple modifications of i in a single expression.

Story

In an embedded project, the counter value was increased as part of a complex expression: if (buffer[i++] == TERMINATOR && ++i < SIZE) ... — on the “hardware”, sometimes an incorrect index was produced due to different evaluation orders, leading to reading uninitialized data.

Story

When porting code to another compiler, the difference in the implementation of the order of operand evaluation caused a loop of the type while (arr[i++] && i < MAX && arr[++i]) to behave unpredictably. The bug was only discovered during the testing phase on the client’s device.