osd@hou2d.UUCP (Orlando Sotomayor-Diaz) (05/11/86)
From: Orlando Sotomayor-Diaz (The Moderator) <cbosgd!std-c>
mod.std.c Digest Sun, 11 May 86 Volume 16 : Issue 7
Today's Topics:
Differences from April 1985 to February 1986 Draft Standard, Part 6
----------------------------------------------------------------------
Date: Sun, 27 Apr 86 01:17:06 est
From: <ihnp4!utcsri!lsuc!msb%utcsri>
Subject: Differences from April 1985 to February 1986 Draft Standard, Part 6
To: cbosgd!std-c%utcsri
# C.3.3.3 Unary arithmetic operators
* Except that it inhibits regrouping {--> of subexpressions of E
with subexpressions outside of E}, the expression +E is
equivalent to (0+E).
# C.3.3.4 The sizeof operator
<--O The sizeof operator ... may be applied to any object except a
<--O bit-field member of a structure, which is the only kind of object
<--O whose size might not be an integral number of bytes.
N--> The sizeof operator may not be applied to any expression that has
N--> type function, bit-field, or void, or to the parenthesized name
N--> of the type of such an expression.
# C.3.3.4 The sizeof operator
* The size is determined from the {declaration --> type} of the
* {object in the -->} operand {expression -->}, which is not itself
* evaluated. The result is {an unsigned constant that has integral
type and may be used anywhere such a constant is required --> an
integer constant}. The size of the result is implementation-
* defined {-->, and its type (an unsigned integral type) is size_t
defined in the <stddef.h> header}.
# C.3.3.4 The sizeof operator
* When applied to a formal parameter that has array {--> or func-
* tion} type, the sizeof operator yields the size of {a pointer to
a member of such an array --> the pointer obtained by converting
as in #C.2.2.1}.
# C.3.3.4 The sizeof operator
<--O double *dp = alloc(sizeof (double));
<--O ...
<--O sizeof(array)/sizeof(array[0])
N--> double *dp = alloc(sizeof *dp);
N--> ...
N--> sizeof array / sizeof array[0]
# C.3.3.4 The sizeof operator
* Forward references: ... {--> terms and common definitions
(#D.1.1)}, ...
# C.3.4 Cast operators
* An {--> arbitrary} integer may be converted to a pointer. {If
the space provided was long enough, the mapping always carries an
integer converted from a pointer back to the same pointer, but is
otherwise --> The result is} implementation-defined.
# C.3.4 Cast operators
N--> A cast does not yield an lvalue.
# C.3.6 Additive operators
When two pointers to members of the same array object are sub-
tracted ... the size of the result is implementation-defined
* {-->, and its type (a signed integral type) is ptrdiff_t defined
in the <stddef.h> header}.
# C.3.9 Equality operators
Both of the operands may have arithmetic type, or both may be
* pointers to the same type. In addition, {--> one may be an ob-
ject pointer and the other a pointer to void, or} one may be a
* pointer and the other {an integral constant expression with the
value 0 --> a null pointer constant}.
N--> ... If one of the operands is a pointer to void, the other is
N--> converted to that type.
# C.3.15 Conditional operator
Both the second and third operands shall have arithmetic type, or
shall have the same structure, union, or pointer type, or shall
* be void expressions. In addition, {--> one may be an object
pointer and the other a pointer to void, or} one may be a pointer
* and the other {an integral constant expression with the value 0
--> a null pointer constant}.
N--> ... If one of the operands is a pointer to void, the other
N--> operand is converted to that type and the result has that type.
N--> A conditional expression does not yield an lvalue.
# C.3.16 Assignment operators
* An assignment operator shall have a {--> modifiable} lvalue as
its left operand.
* An assignment operator stores a value in the object {specified by
the lvalue --> designated by the left operand}. An assignment
expression has the type of the left operand and the value of the
* left operand after the assignment {-->, but is not an lvalue}.
# C.3.16.1 Simple assignment
<--O The operands may each have arithmetic type or may be structure or
<--O union objects that have the same type. In addition, the left
<--O operand may be a pointer, in which case the right operand must be
<--O a pointer that has the same type or has type "pointer to void",
<--O or must be an integral constant expression with the value 0.
N--> Both the operands shall have arithmetic type or shall have the
N--> same structure, union, or pointer type. In addition, if the left
N--> operand is a pointer, either of the operands may be a pointer to
N--> void, or the right operand may be a null pointer constant.
* ... If the left operand is a pointer {and the right operand an
integral constant expression with the value 0, the constant is
converted into a null pointer -->, if either of the operands is a
pointer to void or the right operand is a null pointer constant,
the right operand is converted to the type of the left operand}.
# C.3.17 Comma operator
N--> A comma operator does not yield an lvalue.
# C.4 CONSTANT EXPRESSIONS
A function-call operator (), an increment or decrement operator
* ++ or --, {an indirection * unary operator, -->} or an assignment
operator shall not appear in any constant expression.
... The array-subscripting [] and member-access . and -> opera-
* tors and the "address-of" & {--> and indirection *} unary opera-
* tors shall not appear {,--> except in an expression that is the
operand of a sizeof operator}.
<--O For constant expressions in initializers, in addition to integral
<--O constant expressions as discussed previously, one can also use
<--O floating constants and arbitrary casts and can apply the unary &
<--O operator to objects that have static storage duration and to ar-
<--O rays that have static storage duration subscripted with an in-
<--O tegral constant expression. The unary & operation can also be
<--O implied by appearance of a function identifier or an unsubscript-
<--O ed array identifier. In short, the expression must evaluate to a
<--O constant, to the identifier or a previously declared function, or
<--O to the address of a previously declared object that has static
<--O storage duration plus or minus an integral constant expression,
<--O or to the difference in addresses of two previously declared ob-
<--O jects that are members of the same aggregate.
N--> For constant expressions in initializers, in addition to integral
N--> constant expressions as discussed previously, floating constants
N--> and arbitrary casts may be used. Lvalues of objects that have
N--> static storage duration or function identifiers may also be used
N--> to specify addresses, explicitly with the unary & operator or im-
N--> plicitly for unsubscripted array identifiers or function identif-
N--> iers. A constant difference in the addresses of two members of
N--> the same aggregrate may be used. As a special case, a suitably
N--> cast null pointer may be used to derive an integral constant ex-
N--> pression, the value of which is the offset in bytes of an element
N--> of a structure from its beginning, by means of an expression of
N--> the form
N--> (int)&((TYPE-SPECIFIER)0)->POSTFIX-EXPRESSION
N--> where TYPE-SPECIFIER specifies the type of a pointer to a struc-
N--> ture and POSTFIX-EXPRESSION designates any member of that struc-
N--> ture or of a subaggregate (any array subscript shall be an in-
N--> tegral constant expression).
------------------------------
End of mod.std.c Digest - Sun, 11 May 86 07:34:03 EDT
******************************
USENET -> posting only through cbosgd!std-c.
ARPA -> ... through cbosgd!std-c@BERKELEY.ARPA (NOT to INFO-C)
In all cases, you may also reply to the author(s) above.