Are ++i, i = i + 1 and i += 1 equivalent in C/C++?

Question

My actual concern is about whether the expressions of ++i;, i = i + 1; and i += 1; are one-hundred percent equivalent to each other, if i is defined before.

++i; - i gets immediately incremented by 1 within the statement, as opposed to i++; where the incremetation by 1 is done after the expression.
i = i + 1; - i gets immediately incremented by 1 within the statement.
i += 1; - i gets immediately incremented by 1 within the statement.

Are there *any kind of differences between those expressions or are they 100% equivalent?

*"Any" may refer to syntax and semantics, but also to performance and memory-management.

A minor correction: in `i++` `i` is also immediately incremented by 1, however the expression returns a temporary with the previous value of `i`. — r3mus n0x, Feb 09 '20 at 12:01
@exnihilo I wanted to ask for both because I did not see a difference and would like to use the respective statements with both languages, if it is possible. — RobertS supports Monica Cellio, Feb 09 '20 at 12:05
@Andreas-he-her- That gives an answer to the C++ part of using `++i`. Thank you very much for it. But what about the comparison between `i = i + 1;` and `i += 1;` in C++ and the C part of the question? — RobertS supports Monica Cellio, Feb 09 '20 at 12:12
@RobertSsupportsMonicaCellio The definitions of their respective implementations is equal in both languages, but the rules of compiler may be different. — Andreas is moving to Codidact, Feb 09 '20 at 12:13
Is your question specific to native c++ type int? Take a look here https://godbolt.org/z/cAH5wf — Eyal D, Feb 09 '20 at 12:15
@Andreas-he-her- Do you mean that `i = i + 1;` and `i += 1;` are equivalent in C and C++? But what about the comparison of `i = i + 1;`, `i += 1;` and `++i` in C? BTW, do you got any reference that `i = i + 1;` and `i += 1;` are equivalent in C and C++? — RobertS supports Monica Cellio, Feb 09 '20 at 12:16
@EyalD Well, yes, consider `i` as of type `int` or any other integer-compatible type. If there are to the context relevant differences between the multiple integer types, I would be glad if you can point them. — RobertS supports Monica Cellio, Feb 09 '20 at 12:18
@RobertSsupportsMonicaCellio Wikipedia has a limited description: https://en.wikipedia.org/wiki/Increment_and_decrement_operators. — Andreas is moving to Codidact, Feb 09 '20 at 12:19
According to https://stackoverflow.com/a/18420558/5229664 they are the same! And it's logical to be same in performance or memory-management because all of them have to go through a same path to compute in memory! — Farbod Ahmadian, Feb 09 '20 at 12:19
@Dialecticus Ok, Thank you for the hint but are they equivalent for fundamental types? — RobertS supports Monica Cellio, Feb 09 '20 at 12:20
@FarbodAhmadian Ok, thank you for the link. But still keeps the question if `i = i + 1` is equivalent to `i += 1` and `++i` in C in any kind of the mentioned topics. — RobertS supports Monica Cellio, Feb 09 '20 at 12:24
@RobertSsupportsMonicaCellio I don't know of a difference between built-in- numerical types (might be), but note that for classes you can overload the operators to do whatever you want — Eyal D, Feb 09 '20 at 12:44

score 7 · Accepted Answer · edited Jun 20 '20 at 09:12

C

In C, i = i+1 and i += 1 are not equivalent if i is an atomic type, because the compound assignment is a read-modify-write operation with memory_order_seq_cst semantics, per C 2018 6.5.16.2 3. I also cannot say the C standard is completely clear on the semantics of i = i+1 and i += 1 in regard to volatile objects. Otherwise, ++i, i = i+1, and i += 1 are equivalent, given that i is merely an identifier, not a placeholder for any more complicated expression.

C++

In C++, the operations are not equivalent. Proof:

This program:

#include <iostream>


class SensitiveToOperations
{
public:
    SensitiveToOperations operator ++() { std::cout << "Preincrement.\n"; return *this; }
    SensitiveToOperations operator +(int that) const { std::cout << "Addition.\n"; return *this; }
    SensitiveToOperations operator =(SensitiveToOperations that) { std::cout << "Assignment.\n"; return *this; }
    SensitiveToOperations operator +=(int that) { std::cout << "AdditionAssignment.\n"; return *this; }
};


int main(void)
{
    SensitiveToOperations i;
    ++i;
    i = i + 1;
    i += 1;
}

produces this output:

Preincrement.
Addition.
Assignment.
AdditionAssignment.

thus showing that different results may be obtained for the different operations.

For fundamental types, the operations may be largely equivalent, but I am not qualified to speak to C++ semantics with regard to atomic or volatile.

The canonical implementation of increment and decrement operators for integer types, is the use of assignment and addition/subtraction, thus we assume `x = ++i` is equal to `i = i + 1; x = i`. The use of `i` further implies an integer type, but I guess there are some uses for overriding these operators with different behaviour. Hope I won't encounter such custom behaviour on integers, though. — Andreas is moving to Codidact, Feb 09 '20 at 12:37

score 4 · Answer 2 · answered Feb 09 '20 at 12:28

In C, ++i is equivalent to (i += 1)

C11 Draft Standard 6.5.3.1p2:

The expression ++E is equivalent to (E+=1).

The expression i += 1 is equivalent to i = i + 1, except that in the first case i is guaranteed to be evaluated only one time. In function calls i += 1 results in a single evaluation.

C11 Draft Standard 6.5.16.2p3:

A compound assignment of the form E1 op = E2 is equivalent to the simple assignment expression E1 = E1 op (E2), except that the lvalue E1 is evaluated only once, and with respect to an indeterminately-sequenced function call, the operation of a compound assignment is a single evaluation. If E1 has an atomic type, compound assignment is a read-modify-write operation with memory_order_seq_cst memory order semantics.

You might expect performance to be marginally better for ++i, given that i is evaluated only once in this expression, but this really comes down to implementation details and how well your compiler optimizes. Performance and memory-management issues are outside of the purview of the language-lawyer tag.

Are ++i, i = i + 1 and i += 1 equivalent in C/C++?

2 Answers2

C

C++