appa.html

c语言编程-c语言作者的书。英文原版。非常好。

<tt>a&lt;b&lt;c</tt> is parsed as <tt>(a&lt;b)&lt;c</tt>, and evaluates to
either 0 or 1.
<p>
&nbsp;&nbsp;&nbsp;&nbsp;<em>relational-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>shift-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>relational-expression</em> <tt>&lt;</tt> <em>shift-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>relational-expression</em> <tt>&gt;</tt> <em>shift-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>relational-expression</em> <tt>&lt;=</tt> <em>shift-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>relational-expression</em> <tt>&gt;=</tt> <em>shift-expression</em>
<p>
The operators <tt>&lt;</tt> (less), <tt>&gt;</tt> (greater), <tt>&lt;=</tt> (less or equal)
and <tt>&gt;=</tt> (greater or equal) all yield 0 if the specified relation is
false and 1 if it is true. The type of the result is <tt>int</tt>. The usual
arithmetic conversions are performed on arithmetic operands. Pointers to
objects of the same type (ignoring any qualifiers) may be compared; the
result depends on the relative locations in the address space of the pointed-to
objects. Pointer comparison is defined only for parts of the same object; if
two pointers point to the same simple object, they compare equal; if the
pointers are to members of the same structure, pointers to objects declared
later in the structure compare higher; if the pointers refer to members of an
array, the comparison is equivalent to comparison of the the corresponding
subscripts. If <tt>P</tt> points to the last member of an array, then <tt>P+1</tt>
compares higher than <tt>P</tt>, even though <tt>P+1</tt> points outside the array.
Otherwise, pointer comparison is undefined.
<p>
<dl><dd><font size="-1">
These rules slightly liberalize the restrictions stated in the first edition,
by permitting comparison of pointers to different members of a structure or
union. They also legalize comparison with a pointer just off the end of an
array.
</font></dl>

<h3><a name="sa.7.10">A.7.10 Equality Operators</a></h3>
&nbsp;&nbsp;&nbsp;&nbsp;<em>equality-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>relational-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>equality-expression</em> <tt>==</tt> <em>relational-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>equality-expression</em> <tt>!=</tt> <em>relational-expression</em>
<p>
The <tt>==</tt> (equal to) and the <tt>!=</tt> (not equal to) operators are
analogous to the relational operators except for their lower precedence.
(Thus <tt>a&lt;b == c&lt;d</tt> is 1 whenever <tt>a&lt;b</tt> and <tt>c&lt;d</tt>
have the same truth-value.)
<p>
The equality operators follow the same rules as the relational operators,
but permit additional possibilities: a pointer may be compared to a constant
integral expression with value 0, or to a pointer to <tt>void</tt>. See
<a href="#sa.6.6">Par.A.6.6</a>.

<h3><a name="sa.7.11">A.7.11 Bitwise AND Operator</a></h3>
&nbsp;&nbsp;&nbsp;&nbsp;<em>AND-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>equality-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>AND-expression</em> <tt>&amp;</tt> <em>equality-expression</em>
<p>
The usual arithmetic conversions are performed; the result is the bitwise
AND function of the operands. The operator applies only to integral operands.

<h3><a name="sa.7.12">A.7.12 Bitwise Exclusive OR Operator</a></h3>
&nbsp;&nbsp;&nbsp;&nbsp;<em>exclusive-OR-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>AND-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>exclusive-OR-expression</em> <tt>^</tt> <em>AND-expression</em>
<p>
The usual arithmetic conversions are performed; the result is the bitwise
exclusive OR function of the operands. The operator applies only to integral
operands.

<h3><a name="sa.7.13">A.7.13 Bitwise Inclusive OR Operator</a></h3>
&nbsp;&nbsp;&nbsp;&nbsp;<em>inclusive-OR-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>exclusive-OR-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>inclusive-OR-expression</em> <tt>|</tt> <em>exclusive-OR-expression</em>
<p>
The usual arithmetic conversions are performed; the result is the bitwise
inclusive OR function of the operands. The operator applies only to integral
operands.

<h3><a name="sa.7.14">A.7.14 Logical AND Operator</a></h3>
&nbsp;&nbsp;&nbsp;&nbsp;<em>logical-AND-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>inclusive-OR-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>logical-AND-expression</em> <tt>&amp;&amp;</tt> <em>inclusive-OR-expression</em>
<p>
The <tt>&amp;&amp;</tt> operator groups left-to-right. It returns 1 if both its operands
compare unequal to zero, 0 otherwise. Unlike <tt>&amp;</tt>, <tt>&amp;&amp;</tt> guarantees
left-to-right evaluation: the first operand is evaluated, including all side
effects; if it is equal to 0, the value of the expression is 0. Otherwise,
the right operand is evaluated, and if it is equal to 0, the expression's
value is 0, otherwise 1.
<p>
The operands need not have the same type, but each must have arithmetic type
or be a pointer. The result is <tt>int</tt>.

<h3><a name="sa.7.15">A.7.15 Logical OR Operator</a></h3>
&nbsp;&nbsp;&nbsp;&nbsp;<em>logical-OR-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>logical-AND-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>logical-OR-expression</em> <tt>||</tt> <em>logical-AND-expression</em>
<p>
The <tt>||</tt> operator groups left-to-right. It returns 1 if either of its
operands compare unequal to zero, and 0 otherwise. Unlike <tt>|</tt>, <tt>||</tt>
guarantees left-to-right evaluation: the first operand is evaluated, including
all side effects; if it is unequal to 0, the value of the expression is 1.
Otherwise, the right operand is evaluated, and if it is unequal to 0, the
expression's value is 1, otherwise 0.
<p>
The operands need not have the same type, but each must have arithmetic type
or be a pointer. The result is <tt>int</tt>.

<h3><a name="sa.7.16">A.7.16 Conditional Operator</a></h3>
&nbsp;&nbsp;&nbsp;&nbsp;<em>conditional-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>logical-OR-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>logical-OR-expression</em> <tt>?</tt> <em>expression</em> <tt>:</tt> <em>conditional-expression</em>
<p>
The first expression is evaluated, including all side effects; if it compares
unequal to 0, the result is the value of the second expression, otherwise that
of the third expression. Only one of the second and third operands is
evaluated. If the second and third operands are arithmetic, the usual
arithmetic conversions are performed to bring them to a common type, and that
type is the type of the result. If both are <tt>void</tt>, or structures or
unions of the same type, or pointers to objects of the same type, the result
has the common type. If one is a pointer and the other the constant 0, the 0
is converted to the pointer type, and the result has that type. If one is a
pointer to <tt>void</tt> and the other is another pointer, the other pointer is
converted to a pointer to <tt>void</tt>, and that is the type of the result.
<p>
In the type comparison for pointers, any type qualifiers
(<a href="#sa.8.2">Par.A.8.2</a>) in the type to which the pointer points
are insignificant, but the result type
inherits qualifiers from both arms of the conditional.

<h3><a name="sa.7.17">A.7.17 Assignment Expressions</a></h3>
There are several assignment operators; all group right-to-left.
<p>
&nbsp;&nbsp;&nbsp;&nbsp;<em>assignment-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>conditional-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>unary-expression assignment-operator assignment-expression</em>
<p>
&nbsp;&nbsp;&nbsp;&nbsp;<em>assignment-operator</em>: one of<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<tt>=  *=  /=  %=  +=  -=  &lt;&lt;=  &gt;&gt;=  &amp;=  ^=  |=</tt>
<p>
All require an lvalue as left operand, and the lvalue must be modifiable: it
must not be an array, and must not have an incomplete type, or be a function.
Also, its type must not be qualified with <tt>const</tt>; if it is a structure
or union, it must not have any member or, recursively, submember qualified
with <tt>const</tt>. The type of an assignment expression is that of its left
operand, and the value is the value stored in the left operand after the
assignment has taken place.
<p>
In the simple assignment with <tt>=</tt>, the value of the expression replaces
that of the object referred to by the lvalue. One of the following must be
true: both operands have arithmetic type, in which case the right operand is
converted to the type of the left by the assignment; or both operands are
structures or unions of the same type; or one operand is a pointer and the
other is a pointer to <tt>void</tt>, or the left operand is a pointer and the
right operand is a constant expression with value 0; or both operands are
pointers to functions or objects whose types are the same except for the
possible absence of <tt>const</tt> or <tt>volatile</tt> in the right operand.
<p>
An expression of the form <tt>E1 <em>op</em>= E2</tt> is equivalent to
<tt>E1 = E1 <em>op</em> (E2)</tt> except that <tt>E1</tt> is evaluated only once.

<h3><a name="sa.7.18">A.7.18 Comma Operator</a></h3>
&nbsp;&nbsp;&nbsp;&nbsp;<em>expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>assignment-expression</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>expression</em> <tt>,</tt> <em>assignment-expression</em>
<p>
A pair of expressions separated by a comma is evaluated left-to-right, and the
value of the left expression is discarded. The type and value of the result are
the type and value of the right operand. All side effects from the evaluation
of the left-operand are completed before beginning the evaluation of the
right operand. In contexts where comma is given a special meaning, for example
in lists of function arguments (<a href="#sa.7.3.2">Par.A.7.3.2</a>) and lists
of initializers (<a href="#sa.8.7">Par.A.8.7</a>), the required syntactic unit
is an assignment expression, so the comma operator appears only in a
parenthetical grouping, for example,
<pre>
   f(a, (t=3, t+2), c)
</pre>
has three arguments, the second of which has the value 5.

<h3><a name="sa.7.19">A.7.19 Constant Expressions</a></h3>
Syntactically, a constant expression is an expression restricted to a subset
of operators:
<p>
&nbsp;&nbsp;&nbsp;&nbsp;<em>constant-expression</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>conditional-expression</em>
<p>
Expressions that evaluate to a constant are required in several contexts:
after <tt>case</tt>, as array bounds and bit-field lengths, as the value of an
enumeration constant, in initializers, and in certain preprocessor expressions.
<p>
Constant expressions may not contain assignments, increment or decrement
operators, function calls, or comma operators; except in an operand of <tt>
sizeof</tt>. If the constant expression is required to be integral, its operands
must consist of integer, enumeration, character, and floating constants; casts
must specify an integral type, and any floating constants must be cast to
integer. This necessarily rules out arrays, indirection, address-of, and
structure member operations. (However, any operand is permitted for
<tt>sizeof</tt>.)
<p>
More latitude is permitted for the constant expressions of initializers; the
operands may be any type of constant, and the unary <tt>&amp;</tt> operator may be
applied to external or static objects, and to external and static arrays
subscripted with a constant expression. The unary <tt>&amp;</tt> operator can also
be applied implicitly by appearance of unsubscripted arrays and functions.
Initializers must evaluate either to a constant or to the address of a
previously declared external or static object plus or minus a constant.
<p>
Less latitude is allowed for the integral constant expressions after
<tt>#if</tt>; <tt>sizeof</tt> expressions, enumeration constants, and casts are
not permitted. See <a href="#sa.12.5">Par.A.12.5</a>.

<h2><a name="sa.8">A.8 Declarations</a></h2>
Declarations specify the interpretation given to each identifier; they do not
necessarily reserve storage associated with the identifier. Declarations that
reserve storage are called <em>definitions</em>. Declarations have the form
<p>
&nbsp;&nbsp;&nbsp;&nbsp;<em>declaration</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>declaration-specifiers init-declarator-list<sub>opt</sub></em><tt>;</tt>
<p>
The declarators in the init-declarator list contain the identifiers being
declared; the declaration-specifiers consist of a sequence of type and storage
class specifiers.
<p>
&nbsp;&nbsp;&nbsp;&nbsp;<em>declaration-specifiers</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>storage-class-specifier declaration-specifiers<sub>opt</sub></em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>type-specifier declaration-specifiers<sub>opt</sub></em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>type-qualifier declaration-specifiers<sub>opt</sub></em>
<p>
&nbsp;&nbsp;&nbsp;&nbsp;<em>init-declarator-list</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>init-declarator</em><br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<em>init-declarator-list</em> <tt>,</tt> <em>init-declarator</em>
<p>
&nbsp;&nbsp;&nbsp;&nbsp;<em>init-declarator</em>:<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nb