[ ... ]
1) Does it mean that prefix operator in C does not produce Lvalue in C
unlike C++ ?
That's correct -- in C 6.5.16/3 specifies that: " An assignment
expression hs the value of the left operand after the assignment, but is
not an lvalue."
6.5.16.2/3 says: "A compound assignment of the form E1 op= E2 differs
from the simple assignment E1 = E1 op (E2) only in thta the lvalue E1 is
evaluated only once."
Finally, 6.5.3.1/2 says: "The expression ++E is equivalent to (E+=1)."
and 6.5.3.1/3 says: "The prefix -- operator is analogous to the prefix
++ operator, except that the value of the operand is decremented."
So, in C a prefix increment or decrement does no produce an lvalue.
2) I read that, in C++ postfix increment and decrement operator have
higher precedence than the prefix operator. But in C they have the
same precedence. Am I right or wrong ?
You're not exactly right, but not completely wrong either. Neither the C
nor C++ standard specifies precedence directly -- in both cases, the
precedence must be deduced from the grammar.
In both cases, the grammar specifies postfix operators with higher
precedence than prefix. In reality, however, this doesn't really matter
much -- the only time the relative precedence of a prefix and postfix
operator matters is if both are being applied to the same operand, such
as "++a++;".
In C, since the operators never produce lvalues, and the operand of the
prefix operator needs to be an lvalue, you can never have an expression
where both the pre- and post-fix operators are applied to the same
operand -- so there's never a conflict between the two that you need to
resolve via precedence.
In C++, for built-in types, the situation is the same. A user-defined
type, however, can overload the operators and return modifiable lvalues
in both cases:
For example:
#include <iostream>
class X {
int x;
public:
X(int init = 0) : x(init) {}
int &operator++() { return ++x; }
int &operator++(int) { return ++x; }
operator int() { return x; }
};
int main() {
X x;
++x++;
std::cout << x;
return 0;
}
#include <iostream>
class X {
int x;
public:
X(int init = 0) : x(init) {}
int &operator++() { return ++x; }
// well-formed but truly evil code:
int &operator++(int) { return ++x; }
operator int() { return x; }
};
int main() {
X x;
// also well-formed:
++x++;
std::cout << (int) x;
return 0;
}
Now, the difference in precedence is meaningful. We're applying both
operators to the same operand, and the higher effective precedence of
the postfix operator means the "++x++" is equivalent to:
x.operator++(int).operator++();
rather than:
x.operator++().operator++(int);
For built-in types, the postfix operators do not produce modifiable
lvalues, so an expression like this is ill-formed, and the difference in
precedence is a moot point, just like in C.
