Jones D.M.The new C standard (C90 and C++).An economic and cultural commentary.2005

relational 1190 operators

pointer operands

equality operators pointer to incomplete type

C++

The discussion on the relational operators is applicable here.

— one operand is a pointer to an object or incomplete type and the other is a pointer to a qualified or 1206 unqualified version of void; or

C++

equality operators null pointer constant

equality operators pointer to void

C++

The C++ Standard supports this combination of operands but does not explicitly specify any sequence of operations that take place prior to the comparison.

If one operand is a pointer to an object or incomplete type and the other is a pointer to a qualified or unquali- 1221 fied version of void, the former is converted to the type of the latter.

C++

pointers compare equal

This conversion is part of the general pointer conversion (4.10) rules in C++. This conversion occurs when two operands have pointer type.

Two pointers compare equal if and only if both are null pointers, both are pointers to the same object (including 1223 a pointer to an object and a subobject at its beginning) or function, both are pointers to one past the last element of the same array object, or one is a pointer to one past the end of one array object and the other is

a pointer to the start of a different array object that happens to immediately follow the first array object in the address space.92)

The following conversion is presumably performed on the operands.

1228 92) Two objects may be adjacent in memory because they are adjacent elements of a larger array or adjacent members of a structure with no padding between them, or because the implementation chose to place them so, even though they are unrelated.

C90

The C90 Standard did not discuss these object layout possibilities.

C++

The C++ Standard does not make these observations.

1229 If prior invalid pointer operations (such as accesses outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined behavior.

footnote 92

pare against 0

5.14p1

&&

result type

5.14p2

&&

sequence point

5.14p2

C++

The result is true if both operands are true and false otherwise.

The result is a bool.

The difference in result type will result in a difference of behavior if the result is the immediate operand of the sizeof operator. Such usage is rare.

All side effects of the first expression except for destruction of temporaries (12.2) happen before the second expression is evaluated.

1248 The || operator shall yield 1 if either of its operands compare unequal to 0;

C++

It returns true if either of its operands is true, and false otherwise.

The difference in operand types is not applicable because C++ defines equality to return true or false. The difference in return value will not cause different behavior because false and true will be converted to 0 and 1 when required.

1250 The result has type int.

C++

The result is a bool.

The difference in result type will result in a difference of behavior if the result is the immediate operand of the sizeof operator. Such usage is rare.

1252 there is a sequence point after the evaluation of the first operand.

C++

All side effects of the first expression except for destruction of temporaries (12.2) happen before the second expression is evaluated.

The differences are discussed elsewhere.

||

operand compared against 0

5.15p1

||

result type

5.15p2

operator || sequence point

5.15p2

1244 &&

sequence point

1254

conditional-expression: logical-OR-expression

logical-OR-expression ? expression : conditional-expression

C++

conditional-expression: logical-or-expression logical-or-expression ? expression : assignment-expression

Supporting an assignment-expression as the third operand enables the use of a throw-expression; for instance:

conditionalexpression

syntax

5.16

1278 assignmentexpression syntax

pointer to compatible types

5.16p6

subtraction 1149 pointer operands

C++

— The second and third operands have pointer type, or one has pointer type and the other is a null pointer constant; pointer conversions (4.10) and qualification conversions (4.4) are performed to bring them to their composite pointer type (5.9).

These conversions will not convert a pointer to an enumerated type to a pointer to integer type.

If one pointed-to type is an enumerated type and the other pointed-to type is the compatible integer type. C permits such operands to occur in the same conditional-expression. C++ does not. See pointer subtraction for an example.

— one operand is a pointer to an object or incomplete type and the other is a pointer to a qualified or 1262 unqualified version of void.

C++

1268 If an attempt is made to modify the result of a conditional operator or to access it after the next sequence point, the behavior is undefined.

C90

Wording to explicitly specify this undefined behavior is new in the C99 Standard.

conditional operator

attempt to modify

EXAMPLE ?: common pointer type

1extern int glob;

2

3void f(void)

4{

10((glob > 2) ? loc_i : loc_s) = 3; // ill-formed

11}

EXAMPLE The common type that results when the second and third operands are pointers is determined in 1277 two independent stages. The appropriate qualifiers, for example, do not depend on whether the two pointers

have compatible types. Given the declarations

const void *c_vp; void *vp;

const int *c_ip; volatile int *v_ip; int *ip;

const char *c_cp;

the third column in the following table is the common type that is the result of a conditional expression in which the first two columns are the second and third operands (in either order):

assignmentexpression syntax

C90

This example is new in C99.

6.5.16 Assignment operators

1278

assignment-expression: conditional-expression

unary-expression assignment-operator assignment-expression assignment-operator: one of

= *= /= %= += -= <<= >>= &= ^= |=

C++

assignment-expression: conditional-expression logical-or-expression assignment-operator assignment-expression throw-expression

For some types, a cast is an lvalue in C++.

Constraints

1279 An assignment operator shall have a modifiable lvalue as its left operand.

C90

The C99 Standard has removed the requirement, that was in C90, which lvalues refer to objects. This has resulted in the conformance status of the assignment 1=3 changing from a constraint violation to undefined behavior. The lvalue 1 does not designate an object and is not const-qualified. Therefore it is not ruled out from being modifiable in C99.

Semantics

1281 An assignment expression has the value of the left operand after the assignment, but is not an lvalue.

C++

. . . ; the result is an lvalue.

The C++ DR #222 (which at the time of this writing is at the drafting stage) queries some of the consequences of the result being an lvalue.

Source developed using a C++ translator may contain assignments that are a constraint violation if processed by a C translator.

1extern int glob;

2

3void f(void)

4{

5int x;

6volatile int y;

7

8(glob += 5) += 6; /* constraint violation */

13x = y = 0; /* equivalent to y=0; x=0; */

14// equivalent to y=0; x=y;

15}

1283 The side effect of updating the stored value of the left operand shall occur between the previous and the next sequence point.

C++

5.17

1121 footnote

85

assignment operator modifiable lvalue

717 lvalue

717 lvalue

assignment value of

5.17p1

assignment

when side effect occurs