because in those cases where wording in this International Standard describes the behavior for a construct
as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
because in those cases where wording in this International Standard describes the behavior for a construct
as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
or with two parameters (referred to here as argc and argv, though any names may be
used, as they are local to the function in which they are declared):
<pre>
or with two parameters (referred to here as argc and argv, though any names may be
used, as they are local to the function in which they are declared):
<pre>
or equivalent;<sup><a href="#note9"><b>9)</b></a></sup> or in some other implementation-defined manner.
<p><!--para 2 -->
If they are declared, the parameters to the main function shall obey the following
or equivalent;<sup><a href="#note9"><b>9)</b></a></sup> or in some other implementation-defined manner.
<p><!--para 2 -->
If they are declared, the parameters to the main function shall obey the following
the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
were replaced by the constant 2.0, which has type double).
the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
were replaced by the constant 2.0, which has type double).
x = (x * y) * z; // not equivalent to x *= y * z;
z = (x - y) + y ; // not equivalent to z = x;
z = x + x * y; // not equivalent to z = x * (1.0 + y);
x = (x * y) * z; // not equivalent to x *= y * z;
z = (x - y) + y ; // not equivalent to z = x;
z = x + x * y; // not equivalent to z = x * (1.0 + y);
due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
which overflows produce an explicit trap and in which the range of values representable by an int is
[-32768, +32767], the implementation cannot rewrite this expression as
<pre>
due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
which overflows produce an explicit trap and in which the range of values representable by an int is
[-32768, +32767], the implementation cannot rewrite this expression as
<pre>
since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
while the original expression would not; nor can the expression be rewritten either as
<pre>
since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
while the original expression would not; nor can the expression be rewritten either as
<pre>
since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
in which overflow silently generates some value and where positive and negative overflows cancel, the
above expression statement can be rewritten by the implementation in any of the above ways because the
since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
in which overflow silently generates some value and where positive and negative overflows cancel, the
above expression statement can be rewritten by the implementation in any of the above ways because the
but the actual increment of p can occur at any time between the previous sequence point and the next
sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
value.
but the actual increment of p can occur at any time between the previous sequence point and the next
sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
value.
the following 29 graphic characters
<pre>
! " # % & ' ( ) * + , - . / :
the following 29 graphic characters
<pre>
! " # % & ' ( ) * + , - . / :
the space character, and control characters representing horizontal tab, vertical tab, and
form feed. The representation of each member of the source and execution basic
character sets shall fit in a byte. In both the source and execution basic character sets, the
the space character, and control characters representing horizontal tab, vertical tab, and
form feed. The representation of each member of the source and execution basic
character sets shall fit in a byte. In both the source and execution basic character sets, the
(absolute value) to those shown, with the same sign.
<ul>
<li> number of bits for smallest object that is not a bit-field (byte)
(absolute value) to those shown, with the same sign.
<ul>
<li> number of bits for smallest object that is not a bit-field (byte)
b base or radix of exponent representation (an integer > 1)
e exponent (an integer between a minimum emin and a maximum emax )
p precision (the number of base-b digits in the significand)
b base or radix of exponent representation (an integer > 1)
e exponent (an integer between a minimum emin and a maximum emax )
p precision (the number of base-b digits in the significand)
A floating-point number (x) is defined by the following model:
<pre>
p
x = s b<sup>e</sup> (Sum) f<sub>k</sub> b<sup>-k</sup> , emin <= e <= emax
A floating-point number (x) is defined by the following model:
<pre>
p
x = s b<sup>e</sup> (Sum) f<sub>k</sub> b<sup>-k</sup> , emin <= e <= emax
operations and constants to the range and precision of the long double
type;
2 evaluate all operations and constants to the range and precision of the
operations and constants to the range and precision of the long double
type;
2 evaluate all operations and constants to the range and precision of the
those shown, with the same sign:
<ul>
<li> radix of exponent representation, b
those shown, with the same sign:
<ul>
<li> radix of exponent representation, b
<li> number of decimal digits, n, such that any floating-point number in the widest
supported floating type with pmax radix b digits can be rounded to a floating-point
number with n decimal digits and back again without change to the value,
<pre>
{ pmax log10 b if b is a power of 10
{
<li> number of decimal digits, n, such that any floating-point number in the widest
supported floating type with pmax radix b digits can be rounded to a floating-point
number with n decimal digits and back again without change to the value,
<pre>
{ pmax log10 b if b is a power of 10
{
<li> number of decimal digits, q, such that any floating-point number with q decimal digits
can be rounded into a floating-point number with p radix b digits and back again
without change to the q decimal digits,
<li> number of decimal digits, q, such that any floating-point number with q decimal digits
can be rounded into a floating-point number with p radix b digits and back again
without change to the q decimal digits,
<li> minimum negative integer such that FLT_RADIX raised to one less than that power is
a normalized floating-point number, emin
<li> minimum negative integer such that FLT_RADIX raised to one less than that power is
a normalized floating-point number, emin
<li> minimum negative integer such that 10 raised to that power is in the range of
normalized floating-point numbers, [^log10 b<sup>emin -1</sup>^]
<li> minimum negative integer such that 10 raised to that power is in the range of
normalized floating-point numbers, [^log10 b<sup>emin -1</sup>^]
<li> maximum integer such that FLT_RADIX raised to one less than that power is a
representable finite floating-point number, emax
<li> maximum integer such that FLT_RADIX raised to one less than that power is a
representable finite floating-point number, emax
<li> maximum integer such that 10 raised to that power is in the range of representable
finite floating-point numbers, [_log10 ((1 - b<sup>-p</sup>)b<sup>emax</sup>)_]
<li> maximum integer such that 10 raised to that power is in the range of representable
finite floating-point numbers, [_log10 ((1 - b<sup>-p</sup>)b<sup>emax</sup>)_]
</ul>
<p><!--para 10 -->
The values given in the following list shall be replaced by constant expressions with
implementation-defined values that are greater than or equal to those shown:
<ul>
<li> maximum representable finite floating-point number, (1 - b<sup>-p</sup>)b<sup>emax</sup>
</ul>
<p><!--para 10 -->
The values given in the following list shall be replaced by constant expressions with
implementation-defined values that are greater than or equal to those shown:
<ul>
<li> maximum representable finite floating-point number, (1 - b<sup>-p</sup>)b<sup>emax</sup>
<li> the difference between 1 and the least value greater than 1 that is representable in the
given floating point type, b<sup>1-p</sup>
<!--page 39 -->
<li> the difference between 1 and the least value greater than 1 that is representable in the
given floating point type, b<sup>1-p</sup>
<!--page 39 -->
<p><!--para 12 -->
Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
should be the identity function.
<p><!--para 12 -->
Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
should be the identity function.
If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
precision), then DECIMAL_DIG would be 21.
If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
precision), then DECIMAL_DIG would be 21.
definitions are listed on separate lines, except when prefaced by the words ''one of''. An
optional symbol is indicated by the subscript ''opt'', so that
<pre>
definitions are listed on separate lines, except when prefaced by the words ''one of''. An
optional symbol is indicated by the subscript ''opt'', so that
<pre>
indicates an optional expression enclosed in braces.
<p><!--para 2 -->
When syntactic categories are referred to in the main text, they are not italicized and
indicates an optional expression enclosed in braces.
<p><!--para 2 -->
When syntactic categories are referred to in the main text, they are not italicized and
EXAMPLE Given the following two file scope declarations:
<pre>
int f(int (*)(), double (*)[3]);
EXAMPLE Given the following two file scope declarations:
<pre>
int f(int (*)(), double (*)[3]);
<p><!--para 5 -->
As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
characters in an identifier; the limit for an external name (an identifier that has external
<p><!--para 5 -->
As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
characters in an identifier; the limit for an external name (an identifier that has external
The identifier __func__ shall be implicitly declared by the translator as if,
immediately following the opening brace of each function definition, the declaration
<pre>
The identifier __func__ shall be implicitly declared by the translator as if,
immediately following the opening brace of each function definition, the declaration
<pre>
appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note61"><b>61)</b></a></sup>
<p><!--para 2 -->
This name is encoded as if the implicit declaration had been written in the source
appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note61"><b>61)</b></a></sup>
<p><!--para 2 -->
This name is encoded as if the implicit declaration had been written in the source
The double-quote " and question-mark ? are representable either by themselves or by the
escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
shall be represented, respectively, by the escape sequences \' and \\.
The double-quote " and question-mark ? are representable either by themselves or by the
escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
shall be represented, respectively, by the escape sequences \' and \\.
s-char:
any member of the source character set except
the double-quote ", backslash \, or new-line character
s-char:
any member of the source character set except
the double-quote ", backslash \, or new-line character
produces a single character string literal containing the two characters whose values are '\x12' and '3',
because escape sequences are converted into single members of the execution character set just prior to
adjacent string literal concatenation.
produces a single character string literal containing the two characters whose values are '\x12' and '3',
because escape sequences are converted into single members of the execution character set just prior to
adjacent string literal concatenation.
except for their spelling.<sup><a href="#note68"><b>68)</b></a></sup>
<p><b> Forward references</b>: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
(<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
except for their spelling.<sup><a href="#note68"><b>68)</b></a></sup>
<p><b> Forward references</b>: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
(<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
by a { on the left and a } on the right).
<pre>
{0x3}{<}{1}{/}{a}{.}{h}{>}{1e2}
{#}{include} {<1/a.h>}
forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
by a { on the left and a } on the right).
<pre>
{0x3}{<}{1}{/}{a}{.}{h}{>}{1e2}
{#}{include} {<1/a.h>}
glue(/,/) k(); // syntax error, not comment
/*//*/ l(); // equivalent to l();
m = n//**/o
glue(/,/) k(); // syntax error, not comment
/*//*/ l(); // equivalent to l();
m = n//**/o
Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
the function pointed to by pf[f1()] is called.
the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
the function pointed to by pf[f1()] is called.
<p><b> Forward references</b>: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
<p><b> Forward references</b>: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
initializes p to point to the first element of an array of two ints, the first having the value two and the
second, four. The expressions in this compound literal are required to be constant. The unnamed object
has static storage duration.
initializes p to point to the first element of an array of two ints, the first having the value two and the
second, four. The expressions in this compound literal are required to be constant. The unnamed object
has static storage duration.
p is assigned the address of the first element of an array of two ints, the first having the value previously
pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
unnamed object has automatic storage duration.
p is assigned the address of the first element of an array of two ints, the first having the value previously
pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
unnamed object has automatic storage duration.
created using compound literals can be passed to functions without depending on member order:
<pre>
drawline((struct point){.x=1, .y=1},
created using compound literals can be passed to functions without depending on member order:
<pre>
drawline((struct point){.x=1, .y=1},
Or, if drawline instead expected pointers to struct point:
<pre>
drawline(&(struct point){.x=1, .y=1},
Or, if drawline instead expected pointers to struct point:
<pre>
drawline(&(struct point){.x=1, .y=1},
- (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}</pre>
+ (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}
+</pre>
The first always has static storage duration and has type array of char, but need not be modifiable; the last
two have automatic storage duration when they occur within the body of a function, and the first of these
two is modifiable.
The first always has static storage duration and has type array of char, but need not be modifiable; the last
two have automatic storage duration when they occur within the body of a function, and the first of these
two is modifiable.
EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
and can even be shared. For example,
<pre>
EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
and can even be shared. For example,
<pre>
<pre>
struct int_list { int car; struct int_list *cdr; };
struct int_list endless_zeros = {0, &endless_zeros};
<pre>
struct int_list { int car; struct int_list *cdr; };
struct int_list endless_zeros = {0, &endless_zeros};
q = p, p = &((struct s){ j++ });
if (j < 2) goto again;
return p == q && q->i == 1;
q = p, p = &((struct s){ j++ });
if (j < 2) goto again;
return p == q && q->i == 1;
The function f() always returns the value 1.
<p><!--para 17 -->
Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
The function f() always returns the value 1.
<p><!--para 17 -->
Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
The implementation of the alloc function should ensure that its return value is aligned suitably for
conversion to a pointer to double.
<p><!--para 6 -->
EXAMPLE 2 Another use of the sizeof operator is to compute the number of elements in an array:
<pre>
The implementation of the alloc function should ensure that its return value is aligned suitably for
conversion to a pointer to double.
<p><!--para 6 -->
EXAMPLE 2 Another use of the sizeof operator is to compute the number of elements in an array:
<pre>
<p><b> Forward references</b>: common definitions <a href="#7.17"><stddef.h></a> (<a href="#7.17">7.17</a>), declarations (<a href="#6.7">6.7</a>),
structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.6">6.7.6</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>).
<p><b> Forward references</b>: common definitions <a href="#7.17"><stddef.h></a> (<a href="#7.17">7.17</a>), declarations (<a href="#6.7">6.7</a>),
structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.6">6.7.6</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>).
If array a in the above example were declared to be an array of known constant size, and pointer p were
declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
the same.
If array a in the above example were declared to be an array of known constant size, and pointer p were
declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
the same.
relational-expression < shift-expression
relational-expression > shift-expression
relational-expression <= shift-expression
relational-expression < shift-expression
relational-expression > shift-expression
relational-expression <= shift-expression
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):
<pre>
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):
<pre>
the int value returned by the function may be truncated when stored in the char, and then converted back
to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
values as unsigned char (and char is narrower than int), the result of the conversion cannot be
the int value returned by the function may be truncated when stored in the char, and then converted back
to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
values as unsigned char (and char is narrower than int), the result of the conversion cannot be
the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
that is, long int type.
the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
that is, long int type.
The first assignment is unsafe because it would allow the following valid code to attempt to change the
value of the const object c.
The first assignment is unsafe because it would allow the following valid code to attempt to change the
value of the const object c.
of initializers). On the other hand, it can be used within a parenthesized expression or within the second
expression of a conditional operator in such contexts. In the function call
<pre>
of initializers). On the other hand, it can be used within a parenthesized expression or within the second
expression of a conditional operator in such contexts. In the function call
<pre>
the function has three arguments, the second of which has the value 5.
<p><b> Forward references</b>: initialization (<a href="#6.7.8">6.7.8</a>).
the function has three arguments, the second of which has the value 5.
<p><b> Forward references</b>: initialization (<a href="#6.7.8">6.7.8</a>).
the structure struct s has a flexible array member d. A typical way to use this is:
<pre>
int m = /* some value */;
the structure struct s has a flexible array member d. A typical way to use this is:
<pre>
int m = /* some value */;
and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
p had been declared as:
<pre>
and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
p had been declared as:
<pre>
struct s t1 = { 0 }; // valid
struct s t2 = { 1, { <a href="#4.2">4.2</a> }}; // invalid
t1.n = 4; // valid
struct s t1 = { 0 }; // valid
struct s t2 = { 1, { <a href="#4.2">4.2</a> }}; // invalid
t1.n = 4; // valid
The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
<pre>
The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
<pre>
in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
code.
<p><!--para 19 -->
After the further declaration:
<pre>
in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
code.
<p><!--para 19 -->
After the further declaration:
<pre>
and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
purposes, as if the identifiers had been declared as:
<p><!--para 21 -->
<pre>
struct { int n; double d[8]; } *s1;
and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
purposes, as if the identifiers had been declared as:
<p><!--para 21 -->
<pre>
struct { int n; double d[8]; } *s1;
only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
of the structure, they might be copied or simply overwritten with indeterminate values.
only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
of the structure, they might be copied or simply overwritten with indeterminate values.
makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
declares a structure, union, or enumerated type. The list defines the structure content,
<!--page 119 -->
declares a structure, union, or enumerated type. The list defines the structure content,
<!--page 119 -->
specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note113"><b>113)</b></a></sup>
<p><!--para 8 -->
If a type specifier of the form
<pre>
specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note113"><b>113)</b></a></sup>
<p><!--para 8 -->
If a type specifier of the form
<pre>
occurs other than as part of one of the above forms, and no other declaration of the
identifier as a tag is visible, then it declares an incomplete structure or union type, and
declares the identifier as the tag of that type.113)
<p><!--para 9 -->
If a type specifier of the form
<pre>
occurs other than as part of one of the above forms, and no other declaration of the
identifier as a tag is visible, then it declares an incomplete structure or union type, and
declares the identifier as the tag of that type.113)
<p><!--para 9 -->
If a type specifier of the form
<pre>
occurs other than as part of one of the above forms, and a declaration of the identifier as a
tag is visible, then it specifies the same type as that other declaration, and does not
redeclare the tag.
occurs other than as part of one of the above forms, and a declaration of the identifier as a
tag is visible, then it specifies the same type as that other declaration, and does not
redeclare the tag.
specifies a structure that contains an integer and two pointers to objects of the same type. Once this
declaration has been given, the declaration
<pre>
specifies a structure that contains an integer and two pointers to objects of the same type. Once this
declaration has been given, the declaration
<pre>
declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
these declarations, the expression sp->left refers to the left struct tnode pointer of the object to
which sp points; the expression s.right->count designates the count member of the right struct
declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
these declarations, the expression sp->left refers to the left struct tnode pointer of the object to
which sp points; the expression s.right->count designates the count member of the right struct
<p><!--para 12 -->
EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
structures, the declarations
<pre>
struct s1 { struct s2 *s2p; /* ... */ }; // D1
<p><!--para 12 -->
EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
structures, the declarations
<pre>
struct s1 { struct s2 *s2p; /* ... */ }; // D1
specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
D2. To eliminate this context sensitivity, the declaration
<pre>
specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
D2. To eliminate this context sensitivity, the declaration
<pre>
may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
completes the specification of the new type.
may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
completes the specification of the new type.
may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
pi = &ncs.mem; // valid
pi = &cs.mem; // violates type constraints for =
pci = &cs.mem; // valid
pi = &ncs.mem; // valid
pi = &cs.mem; // violates type constraints for =
pci = &cs.mem; // valid
assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
program, then it is never accessed using either of the other two.
assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
program, then it is never accessed using either of the other two.
assert that, during each execution of the function, if an object is accessed through one of the pointer
parameters, then it is not also accessed through the other.
<p><!--para 9 -->
assert that, during each execution of the function, if an object is accessed through one of the pointer
parameters, then it is not also accessed through the other.
<p><!--para 9 -->
extern int d[100];
f(50, d + 50, d); // valid
f(50, d + 1, d); // undefined behavior
extern int d[100];
f(50, d + 50, d); // valid
f(50, d + 1, d); // undefined behavior
illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
modified within function h.
illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
modified within function h.
The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
example, this permits new_vector to return a vector.
The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
example, this permits new_vector to return a vector.
the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
definition are distinct and either may be used for the call.
the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
definition are distinct and either may be used for the call.
where T contains the declaration specifiers that specify a type T (such as int) and D1 is
a declarator that contains an identifier ident. The type specified for the identifier ident in
the various forms of declarator is described inductively using this notation.
<p><!--para 5 -->
If, in the declaration ''T D1'', D1 has the form
<pre>
where T contains the declaration specifiers that specify a type T (such as int) and D1 is
a declarator that contains an identifier ident. The type specified for the identifier ident in
the various forms of declarator is described inductively using this notation.
<p><!--para 5 -->
If, in the declaration ''T D1'', D1 has the form
<pre>
then the type specified for ident is T .
<p><!--para 6 -->
If, in the declaration ''T D1'', D1 has the form
<pre>
then the type specified for ident is T .
<p><!--para 6 -->
If, in the declaration ''T D1'', D1 has the form
<pre>
then ident has the type specified by the declaration ''T D''. Thus, a declarator in
parentheses is identical to the unparenthesized declarator, but the binding of complicated
declarators may be altered by parentheses.
then ident has the type specified by the declaration ''T D''. Thus, a declarator in
parentheses is identical to the unparenthesized declarator, but the binding of complicated
declarators may be altered by parentheses.
<p><!--para 7 -->
As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
function declarators that modify an arithmetic, structure, union, or incomplete type, either
<p><!--para 7 -->
As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
function declarators that modify an arithmetic, structure, union, or incomplete type, either
and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
D[ type-qualifier-list<sub>opt</sub> assignment-expression<sub>opt</sub> ]
D[ static type-qualifier-list<sub>opt</sub> assignment-expression ]
D[ type-qualifier-list static assignment-expression ]
D[ type-qualifier-list<sub>opt</sub> assignment-expression<sub>opt</sub> ]
D[ static type-qualifier-list<sub>opt</sub> assignment-expression ]
D[ type-qualifier-list static assignment-expression ]
and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note123"><b>123)</b></a></sup>
(See <a href="#6.7.5.3">6.7.5.3</a> for the meaning of the optional type qualifiers and the keyword static.)
and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note123"><b>123)</b></a></sup>
(See <a href="#6.7.5.3">6.7.5.3</a> for the meaning of the optional type qualifiers and the keyword static.)
declares an array of float numbers and an array of pointers to float numbers.
<p><!--para 8 -->
EXAMPLE 2 Note the distinction between the declarations
<pre>
extern int *x;
declares an array of float numbers and an array of pointers to float numbers.
<p><!--para 8 -->
EXAMPLE 2 Note the distinction between the declarations
<pre>
extern int *x;
The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
(an incomplete type), the storage for which is defined elsewhere.
The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
(an incomplete type), the storage for which is defined elsewhere.
p = a; // invalid: not compatible because 4 != 6
r = c; // compatible, but defined behavior only if
// n == 6 and m == n+1
p = a; // invalid: not compatible because 4 != 6
r = c; // compatible, but defined behavior only if
// n == 6 and m == n+1
int (*s)[m]; // valid: auto pointer to VLA
extern int (*r)[m]; // invalid: r has linkage and points to VLA
static int (*q)[m] = &B; // valid: q is a static block pointer to VLA
int (*s)[m]; // valid: auto pointer to VLA
extern int (*r)[m]; // invalid: r has linkage and points to VLA
static int (*q)[m] = &B; // valid: q is a static block pointer to VLA
<p><b> Forward references</b>: function declarators (<a href="#6.7.5.3">6.7.5.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
initialization (<a href="#6.7.8">6.7.8</a>).
<p><b> Forward references</b>: function declarators (<a href="#6.7.5.3">6.7.5.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
initialization (<a href="#6.7.8">6.7.8</a>).
and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
T '', then the type specified for ident is ''derived-declarator-type-list function returning
T ''.
and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
T '', then the type specified for ident is ''derived-declarator-type-list function returning
T ''.
declares a function f with no parameters returning an int, a function fip with no parameter specification
returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
declares a function f with no parameters returning an int, a function fip with no parameter specification
returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
declares an array apfi of three pointers to functions returning int. Each of these functions has two
parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
go out of scope at the end of the declaration of apfi.
declares an array apfi of three pointers to functions returning int. Each of these functions has two
parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
go out of scope at the end of the declaration of apfi.
declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
for (int j = 0, k = n*m+300; j < k; j++)
// a is a pointer to a VLA with n*m+300 elements
a[i][j] += x;
for (int j = 0, k = n*m+300; j < k; j++)
// a is a pointer to a VLA with n*m+300 elements
a[i][j] += x;
double maximum(int n, int m, double a[n][m]);
double maximum(int n, int m, double a[*][*]);
double maximum(int n, int m, double a[ ][*]);
double maximum(int n, int m, double a[n][m]);
double maximum(int n, int m, double a[*][*]);
double maximum(int n, int m, double a[ ][*]);
as are:
<pre>
void f(double (* restrict a)[5]);
void f(double a[restrict][5]);
void f(double a[restrict 3][5]);
as are:
<pre>
void f(double (* restrict a)[5]);
void f(double a[restrict][5]);
void f(double a[restrict 3][5]);
(Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
(Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
direct-abstract-declarator<sub>opt</sub> [ type-qualifier-list static
assignment-expression ]
direct-abstract-declarator<sub>opt</sub> [ * ]
direct-abstract-declarator<sub>opt</sub> [ type-qualifier-list static
assignment-expression ]
direct-abstract-declarator<sub>opt</sub> [ * ]
name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
type_ident is defined as a typedef name with the type specified by the declaration
specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
type_ident is defined as a typedef name with the type specified by the declaration
specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
such a structure. The object distance has a type compatible with any other int object.
are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
such a structure. The object distance has a type compatible with any other int object.
EXAMPLE 2 After the declarations
<pre>
typedef struct s1 { int x; } t1, *tp1;
EXAMPLE 2 After the declarations
<pre>
typedef struct s1 { int x; } t1, *tp1;
type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
<!--page 136 -->
type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
<!--page 136 -->
declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
then a function f is declared with type ''function returning signed int with one unnamed parameter
with type pointer to function returning signed int with one unnamed parameter with type signed
int'', and an identifier t with type long int.
then a function f is declared with type ''function returning signed int with one unnamed parameter
with type pointer to function returning signed int with one unnamed parameter with type signed
int'', and an identifier t with type long int.
typedef void fv(int), (*pfv)(int);
void (*signal(int, void (*)(int)))(int);
fv *signal(int, fv *);
typedef void fv(int), (*pfv)(int);
void (*signal(int, void (*)(int)))(int);
fv *signal(int, fv *);
then the current object (defined below) shall have array type and the expression shall be
an integer constant expression. If the array is of unknown size, any nonnegative value is
valid.
<p><!--para 7 -->
If a designator has the form
<pre>
then the current object (defined below) shall have array type and the expression shall be
an integer constant expression. If the array is of unknown size, any nonnegative value is
valid.
<p><!--para 7 -->
If a designator has the form
<pre>
then the current object (defined below) shall have structure or union type and the
identifier shall be the name of a member of that type.
<!--page 138 -->
then the current object (defined below) shall have structure or union type and the
identifier shall be the name of a member of that type.
<!--page 138 -->
EXAMPLE 1 Provided that <a href="#7.3"><complex.h></a> has been #included, the declarations
<pre>
int i = <a href="#3.5">3.5</a>;
EXAMPLE 1 Provided that <a href="#7.3"><complex.h></a> has been #included, the declarations
<pre>
int i = <a href="#3.5">3.5</a>;
defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
and there are three initializers.
defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
and there are three initializers.
is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
y[0]), namely y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and
y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
y[0]), namely y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and
y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
<pre>
int y[4][3] = {
1, 3, 5, 2, 4, 6, 3, 5, 7
<pre>
int y[4][3] = {
1, 3, 5, 2, 4, 6, 3, 5, 7
The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
next three are taken successively for y[1] and y[2].
The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
next three are taken successively for y[1] and y[2].
<pre>
int z[4][3] = {
{ 1 }, { 2 }, { 3 }, { 4 }
<pre>
int z[4][3] = {
{ 1 }, { 2 }, { 3 }, { 4 }
initializes the first column of z as specified and initializes the rest with zeros.
<p><!--para 28 -->
EXAMPLE 5 The declaration
<pre>
initializes the first column of z as specified and initializes the rest with zeros.
<p><!--para 28 -->
EXAMPLE 5 The declaration
<pre>
is a definition with an inconsistently bracketed initialization. It defines an array with two element
structures: w[0].a[0] is 1 and w[1].a[0] is 2; all the other elements are zero.
is a definition with an inconsistently bracketed initialization. It defines an array with two element
structures: w[0].a[0] is 1 and w[1].a[0] is 2; all the other elements are zero.
contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
object: q[0][0][0] is 1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize
q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
object: q[0][0][0] is 1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize
q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
in a fully bracketed form.
<p><!--para 30 -->
Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
in a fully bracketed form.
<p><!--para 30 -->
Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
- A a = { 1, 2 }, b = { 3, 4, 5 };</pre>
+ A a = { 1, 2 }, b = { 3, 4, 5 };
+</pre>
- int a[] = { 1, 2 }, b[] = { 3, 4, 5 };</pre>
+ int a[] = { 1, 2 }, b[] = { 3, 4, 5 };
+</pre>
defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
This declaration is identical to
<pre>
char s[] = { 'a', 'b', 'c', '\0' },
defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
This declaration is identical to
<pre>
char s[] = { 'a', 'b', 'c', '\0' },
defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
modify the contents of the array, the behavior is undefined.
defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
modify the contents of the array, the behavior is undefined.
const char *nm[] = {
[member_two] = "member two",
[member_one] = "member one",
const char *nm[] = {
[member_two] = "member two",
[member_one] = "member one",
<p><!--para 35 -->
EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
might be misunderstood:
<pre>
struct { int a[3], b; } w[] =
<p><!--para 35 -->
EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
might be misunderstood:
<pre>
struct { int a[3], b; } w[] =
<pre>
int a[MAX] = {
1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
<pre>
int a[MAX] = {
1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
than ten, some of the values provided by the first five initializers will be overridden by the second five.
<p><!--para 38 -->
EXAMPLE 13 Any member of a union can be initialized:
<pre>
In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
than ten, some of the values provided by the first five initializers will be overridden by the second five.
<p><!--para 38 -->
EXAMPLE 13 Any member of a union can be initialized:
<pre>
a default label, control jumps to the labeled statement. If no converted case constant
expression matches and there is no default label, no part of the switch body is
executed.
a default label, control jumps to the labeled statement. If no converted case constant
expression matches and there is no default label, no part of the switch body is
executed.
the object whose identifier is i exists with automatic storage duration (within the block) but is never
initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
access an indeterminate value. Similarly, the call to the function f cannot be reached.
the object whose identifier is i exists with automatic storage duration (within the block) but is never
initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
access an indeterminate value. Similarly, the call to the function f cannot be reached.
while ( expression ) statement
do statement while ( expression ) ;
for ( expression<sub>opt</sub> ; expression<sub>opt</sub> ; expression<sub>opt</sub> ) statement
while ( expression ) statement
do statement while ( expression ) ;
for ( expression<sub>opt</sub> ; expression<sub>opt</sub> ; expression<sub>opt</sub> ) statement
behaves as follows: The expression expression-2 is the controlling expression that is
evaluated before each execution of the loop body. The expression expression-3 is
evaluated as a void expression after each execution of the loop body. If clause-1 is a
behaves as follows: The expression expression-2 is the controlling expression that is
evaluated before each execution of the loop body. The expression expression-3 is
evaluated as a void expression after each execution of the loop body. If clause-1 is a
continue; continue; continue;
/* ... */ /* ... */ /* ... */
contin: ; contin: ; contin: ;
continue; continue; continue;
/* ... */ /* ... */ /* ... */
contin: ; contin: ; contin: ;
unless the continue statement shown is in an enclosed iteration statement (in which
case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note138"><b>138)</b></a></sup>
unless the continue statement shown is in an enclosed iteration statement (in which
case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note138"><b>138)</b></a></sup>
there is no undefined behavior, although there would be if the assignment were done directly (without using
a function call to fetch the value).
there is no undefined behavior, although there would be if the assignment were done directly (without using
a function call to fetch the value).
Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
to the function, whereas the second form does not.
Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
to the function, whereas the second form does not.
Then the definition of g might read
<pre>
void g(int (*funcp)(void))
{
/* ... */
(*funcp)(); /* or funcp(); ... */
Then the definition of g might read
<pre>
void g(int (*funcp)(void))
{
/* ... */
(*funcp)(); /* or funcp(); ... */
F *e(void) { /* ... */ } // e returns a pointer to a function
F *((e))(void) { /* ... */ } // same: parentheses irrelevant
int (*fp)(void); // fp points to a function that has type F
F *e(void) { /* ... */ } // e returns a pointer to a function
F *((e))(void) { /* ... */ } // same: parentheses irrelevant
int (*fp)(void); // fp points to a function that has type F
extern int i2; // refers to previous, whose linkage is internal
extern int i3; // refers to previous, whose linkage is external
extern int i4; // refers to previous, whose linkage is external
extern int i2; // refers to previous, whose linkage is internal
extern int i3; // refers to previous, whose linkage is external
extern int i4; // refers to previous, whose linkage is external
the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
zero on program startup.
<!--page 157 -->
the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
zero on program startup.
<!--page 157 -->
the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
replaced.
the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
replaced.
which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
predefined or if it has been the subject of a #define preprocessing directive without an
intervening #undef directive with the same subject identifier), 0 if it is not.
which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
predefined or if it has been the subject of a #define preprocessing directive without an
intervening #undef directive with the same subject identifier), 0 if it is not.
check whether the controlling constant expression evaluates to nonzero.
<p><!--para 4 -->
Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
check whether the controlling constant expression evaluates to nonzero.
<p><!--para 4 -->
Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
check whether the identifier is or is not currently defined as a macro name. Their
conditions are equivalent to #if defined identifier and #if !defined identifier
respectively.
check whether the identifier is or is not currently defined as a macro name. Their
conditions are equivalent to #if defined identifier and #if !defined identifier
respectively.
searches a sequence of implementation-defined places for a header identified uniquely by
the specified sequence between the < and > delimiters, and causes the replacement of that
directive by the entire contents of the header. How the places are specified or the header
searches a sequence of implementation-defined places for a header identified uniquely by
the specified sequence between the < and > delimiters, and causes the replacement of that
directive by the entire contents of the header. How the places are specified or the header
causes the replacement of that directive by the entire contents of the source file identified
by the specified sequence between the " delimiters. The named source file is searched
for in an implementation-defined manner. If this search is not supported, or if the search
fails, the directive is reprocessed as if it read
<pre>
causes the replacement of that directive by the entire contents of the source file identified
by the specified sequence between the " delimiters. The named source file is searched
for in an implementation-defined manner. If this search is not supported, or if the search
fails, the directive is reprocessed as if it read
<pre>
with the identical contained sequence (including > characters, if any) from the original
directive.
<p><!--para 4 -->
A preprocessing directive of the form
<pre>
with the identical contained sequence (including > characters, if any) from the original
directive.
<p><!--para 4 -->
A preprocessing directive of the form
<pre>
(that does not match one of the two previous forms) is permitted. The preprocessing
tokens after include in the directive are processed just as in normal text. (Each
identifier currently defined as a macro name is replaced by its replacement list of
(that does not match one of the two previous forms) is permitted. The preprocessing
tokens after include in the directive are processed just as in normal text. (Each
identifier currently defined as a macro name is replaced by its replacement list of
EXAMPLE 1 The most common uses of #include preprocessing directives are as in the following:
<pre>
#include <a href="#7.19"><stdio.h></a>
EXAMPLE 1 The most common uses of #include preprocessing directives are as in the following:
<pre>
#include <a href="#7.19"><stdio.h></a>
defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note149"><b>149)</b></a></sup>
to be replaced by the replacement list of preprocessing tokens that constitute the
remainder of the directive. The replacement list is then rescanned for more macro names
defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note149"><b>149)</b></a></sup>
to be replaced by the replacement list of preprocessing tokens that constitute the
remainder of the directive. The replacement list is then rescanned for more macro names
<pre>
# define identifier lparen identifier-list<sub>opt</sub> ) replacement-list new-line
# define identifier lparen ... ) replacement-list new-line
<pre>
# define identifier lparen identifier-list<sub>opt</sub> ) replacement-list new-line
# define identifier lparen ... ) replacement-list new-line
defines a function-like macro with parameters, whose use is similar syntactically to a
function call. The parameters are specified by the optional list of identifiers, whose scope
extends from their declaration in the identifier list until the new-line character that
defines a function-like macro with parameters, whose use is similar syntactically to a
function call. The parameters are specified by the optional list of identifiers, whose scope
extends from their declaration in the identifier list until the new-line character that
#define in_between(a) mkstr(a)
#define join(c, d) in_between(c hash_hash d)
char p[] = join(x, y); // equivalent to
#define in_between(a) mkstr(a)
#define join(c, d) in_between(c hash_hash d)
char p[] = join(x, y); // equivalent to
The expansion produces, at various stages:
<pre>
join(x, y)
in_between(x hash_hash y)
in_between(x ## y)
mkstr(x ## y)
The expansion produces, at various stages:
<pre>
join(x, y)
in_between(x hash_hash y)
in_between(x ## y)
mkstr(x ## y)
In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
this new token is not the ## operator.
In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
this new token is not the ## operator.
causes the specified identifier no longer to be defined as a macro name. It is ignored if
the specified identifier is not currently defined as a macro name.
<p><!--para 3 -->
EXAMPLE 1 The simplest use of this facility is to define a ''manifest constant'', as in
<pre>
#define TABSIZE 100
causes the specified identifier no longer to be defined as a macro name. It is ignored if
the specified identifier is not currently defined as a macro name.
<p><!--para 3 -->
EXAMPLE 1 The simplest use of this facility is to define a ''manifest constant'', as in
<pre>
#define TABSIZE 100
arguments a second time (including side effects) and generating more code than a function if invoked
several times. It also cannot have its address taken, as it has none.
<pre>
arguments a second time (including side effects) and generating more code than a function if invoked
several times. It also cannot have its address taken, as it has none.
<pre>
g(x+(3,4)-w) | h 5) & m
(f)^m(m);
p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
g(x+(3,4)-w) | h 5) & m
(f)^m(m);
p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
results in
<pre>
f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) & f(2 * (0,1))^m(0,1);
int i[] = { 1, 23, 4, 5, };
results in
<pre>
f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) & f(2 * (0,1))^m(0,1);
int i[] = { 1, 23, 4, 5, };
or, after concatenation of the character string literals,
<pre>
printf("x1= %d, x2= %s", x1, x2);
or, after concatenation of the character string literals,
<pre>
printf("x1= %d, x2= %s", x1, x2);
<pre>
#define t(x,y,z) x ## y ## z
int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
<pre>
#define t(x,y,z) x ## y ## z
int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
- t(10,,), t(,11,), t(,,12), t(,,) };</pre>
+ t(10,,), t(,11,), t(,,12), t(,,) };
+</pre>
results in
<pre>
int j[] = { 123, 45, 67, 89,
results in
<pre>
int j[] = { 123, 45, 67, 89,
#define FUNC_LIKE(a) ( a )
#define FUNC_LIKE( a )( /* note the white space */ \
a /* other stuff on this line
#define FUNC_LIKE(a) ( a )
#define FUNC_LIKE( a )( /* note the white space */ \
a /* other stuff on this line
But the following redefinitions are invalid:
<pre>
#define OBJ_LIKE (0) // different token sequence
#define OBJ_LIKE (1 - 1) // different white space
#define FUNC_LIKE(b) ( a ) // different parameter usage
But the following redefinitions are invalid:
<pre>
#define OBJ_LIKE (0) // different token sequence
#define OBJ_LIKE (1 - 1) // different white space
#define FUNC_LIKE(b) ( a ) // different parameter usage
- report(x>y, "x is %d but y is %d", x, y);</pre>
+ report(x>y, "x is %d but y is %d", x, y);
+</pre>
results in
<pre>
fprintf(stderr, "Flag" );
fprintf(stderr, "X = %d\n", x );
puts( "The first, second, and third items." );
((x>y)?puts("x>y"):
results in
<pre>
fprintf(stderr, "Flag" );
fprintf(stderr, "X = %d\n", x );
puts( "The first, second, and third items." );
((x>y)?puts("x>y"):
causes the implementation to behave as if the following sequence of source lines begins
with a source line that has a line number as specified by the digit sequence (interpreted as
a decimal integer). The digit sequence shall not specify zero, nor a number greater than
causes the implementation to behave as if the following sequence of source lines begins
with a source line that has a line number as specified by the digit sequence (interpreted as
a decimal integer). The digit sequence shall not specify zero, nor a number greater than
sets the presumed line number similarly and changes the presumed name of the source
file to be the contents of the character string literal.
<p><!--para 5 -->
A preprocessing directive of the form
<pre>
sets the presumed line number similarly and changes the presumed name of the source
file to be the contents of the character string literal.
<p><!--para 5 -->
A preprocessing directive of the form
<pre>
(that does not match one of the two previous forms) is permitted. The preprocessing
tokens after line on the directive are processed just as in normal text (each identifier
currently defined as a macro name is replaced by its replacement list of preprocessing
(that does not match one of the two previous forms) is permitted. The preprocessing
tokens after line on the directive are processed just as in normal text (each identifier
currently defined as a macro name is replaced by its replacement list of preprocessing
causes the implementation to produce a diagnostic message that includes the specified
sequence of preprocessing tokens.
causes the implementation to produce a diagnostic message that includes the specified
sequence of preprocessing tokens.
where the preprocessing token STDC does not immediately follow pragma in the
directive (prior to any macro replacement)<sup><a href="#note152"><b>152)</b></a></sup> causes the implementation to behave in an
implementation-defined manner. The behavior might cause translation to fail or cause the
where the preprocessing token STDC does not immediately follow pragma in the
directive (prior to any macro replacement)<sup><a href="#note152"><b>152)</b></a></sup> causes the implementation to behave in an
implementation-defined manner. The behavior might cause translation to fail or cause the
<p><b> Forward references</b>: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
(<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
<p><b> Forward references</b>: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
(<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
is processed as follows: The string literal is destringized by deleting the L prefix, if
present, deleting the leading and trailing double-quotes, replacing each escape sequence
\" by a double-quote, and replacing each escape sequence \\ by a single backslash. The
is processed as follows: The string literal is destringized by deleting the L prefix, if
present, deleting the leading and trailing double-quotes, replacing each escape sequence
\" by a double-quote, and replacing each escape sequence \\ by a single backslash. The
The latter form is processed in the same way whether it appears literally as shown, or results from macro
replacement, as in:
<!--page 175 -->
<pre>
#define LISTING(x) PRAGMA(listing on #x)
#define PRAGMA(x) _Pragma(#x)
The latter form is processed in the same way whether it appears literally as shown, or results from macro
replacement, as in:
<!--page 175 -->
<pre>
#define LISTING(x) PRAGMA(listing on #x)
#define PRAGMA(x) _Pragma(#x)
<a href="#7.4"><ctype.h></a> <a href="#7.10"><limits.h></a> <a href="#7.16"><stdbool.h></a> <a href="#7.22"><tgmath.h></a>
<a href="#7.5"><errno.h></a> <a href="#7.11"><locale.h></a> <a href="#7.17"><stddef.h></a> <a href="#7.23"><time.h></a>
<a href="#7.6"><fenv.h></a> <a href="#7.12"><math.h></a> <a href="#7.18"><stdint.h></a> <a href="#7.24"><wchar.h></a>
<a href="#7.4"><ctype.h></a> <a href="#7.10"><limits.h></a> <a href="#7.16"><stdbool.h></a> <a href="#7.22"><tgmath.h></a>
<a href="#7.5"><errno.h></a> <a href="#7.11"><locale.h></a> <a href="#7.17"><stddef.h></a> <a href="#7.23"><time.h></a>
<a href="#7.6"><fenv.h></a> <a href="#7.12"><math.h></a> <a href="#7.18"><stdint.h></a> <a href="#7.24"><wchar.h></a>
If a file with the same name as one of the above < and > delimited sequences, not
provided as part of the implementation, is placed in any of the standard places that are
searched for included source files, the behavior is undefined.
If a file with the same name as one of the above < and > delimited sequences, not
provided as part of the implementation, is placed in any of the standard places that are
searched for included source files, the behavior is undefined.
<li> by use of its associated header (assuredly generating a true function reference)
<pre>
#include <a href="#7.20"><stdlib.h></a>
#undef atoi
const char *str;
/* ... */
<li> by use of its associated header (assuredly generating a true function reference)
<pre>
#include <a href="#7.20"><stdlib.h></a>
#undef atoi
const char *str;
/* ... */
for a compiler whose code generator will accept it.
In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
function may write
<pre>
for a compiler whose code generator will accept it.
In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
function may write
<pre>
whether the implementation's header provides a macro implementation of abs or a built-in
implementation. The prototype for the function, which precedes and is hidden by any macro
definition, is thereby revealed also.
whether the implementation's header provides a macro implementation of abs or a built-in
implementation. The prototype for the function, which precedes and is hidden by any macro
definition, is thereby revealed also.
which is not defined by <a href="#7.2"><assert.h></a>. If NDEBUG is defined as a macro name at the
point in the source file where <a href="#7.2"><assert.h></a> is included, the assert macro is defined
simply as
<pre>
which is not defined by <a href="#7.2"><assert.h></a>. If NDEBUG is defined as a macro name at the
point in the source file where <a href="#7.2"><assert.h></a> is included, the assert macro is defined
simply as
<pre>
The assert macro is redefined according to the current state of NDEBUG each time that
<a href="#7.2"><assert.h></a> is included.
<p><!--para 2 -->
The assert macro is redefined according to the current state of NDEBUG each time that
<a href="#7.2"><assert.h></a> is included.
<p><!--para 2 -->
expands to a constant expression of type const float _Complex, with the value of
the imaginary unit.<sup><a href="#note167"><b>167)</b></a></sup>
<p><!--para 3 -->
The macros
<pre>
expands to a constant expression of type const float _Complex, with the value of
the imaginary unit.<sup><a href="#note167"><b>167)</b></a></sup>
<p><!--para 3 -->
The macros
<pre>
are defined if and only if the implementation supports imaginary types;<sup><a href="#note168"><b>168)</b></a></sup> if defined,
they expand to _Imaginary and a constant expression of type const float
_Imaginary with the value of the imaginary unit.
<p><!--para 4 -->
The macro
<pre>
are defined if and only if the implementation supports imaginary types;<sup><a href="#note168"><b>168)</b></a></sup> if defined,
they expand to _Imaginary and a constant expression of type const float
_Imaginary with the value of the imaginary unit.
<p><!--para 4 -->
The macro
<pre>
expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
defined, I shall expand to _Complex_I.
<p><!--para 5 -->
expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
defined, I shall expand to _Complex_I.
<p><!--para 5 -->
#include <a href="#7.3"><complex.h></a>
double complex cacos(double complex z);
float complex cacosf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex cacos(double complex z);
float complex cacosf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex casin(double complex z);
float complex casinf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex casin(double complex z);
float complex casinf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex catan(double complex z);
float complex catanf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex catan(double complex z);
float complex catanf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex ccos(double complex z);
float complex ccosf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex ccos(double complex z);
float complex ccosf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex csin(double complex z);
float complex csinf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex csin(double complex z);
float complex csinf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex ctan(double complex z);
float complex ctanf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex ctan(double complex z);
float complex ctanf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex cacosh(double complex z);
float complex cacoshf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex cacosh(double complex z);
float complex cacoshf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex casinh(double complex z);
float complex casinhf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex casinh(double complex z);
float complex casinhf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex catanh(double complex z);
float complex catanhf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex catanh(double complex z);
float complex catanhf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex ccosh(double complex z);
float complex ccoshf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex ccosh(double complex z);
float complex ccoshf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex csinh(double complex z);
float complex csinhf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex csinh(double complex z);
float complex csinhf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex ctanh(double complex z);
float complex ctanhf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex ctanh(double complex z);
float complex ctanhf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex cexp(double complex z);
float complex cexpf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex cexp(double complex z);
float complex cexpf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex clog(double complex z);
float complex clogf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex clog(double complex z);
float complex clogf(float complex z);
#include <a href="#7.3"><complex.h></a>
double cabs(double complex z);
float cabsf(float complex z);
#include <a href="#7.3"><complex.h></a>
double cabs(double complex z);
float cabsf(float complex z);
double complex cpow(double complex x, double complex y);
float complex cpowf(float complex x, float complex y);
long double complex cpowl(long double complex x,
double complex cpow(double complex x, double complex y);
float complex cpowf(float complex x, float complex y);
long double complex cpowl(long double complex x,
#include <a href="#7.3"><complex.h></a>
double complex csqrt(double complex z);
float complex csqrtf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex csqrt(double complex z);
float complex csqrtf(float complex z);
#include <a href="#7.3"><complex.h></a>
double carg(double complex z);
float cargf(float complex z);
#include <a href="#7.3"><complex.h></a>
double carg(double complex z);
float cargf(float complex z);
#include <a href="#7.3"><complex.h></a>
double cimag(double complex z);
float cimagf(float complex z);
#include <a href="#7.3"><complex.h></a>
double cimag(double complex z);
float cimagf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex conj(double complex z);
float complex conjf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex conj(double complex z);
float complex conjf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex cproj(double complex z);
float complex cprojf(float complex z);
#include <a href="#7.3"><complex.h></a>
double complex cproj(double complex z);
float complex cprojf(float complex z);
#include <a href="#7.3"><complex.h></a>
double creal(double complex z);
float crealf(float complex z);
#include <a href="#7.3"><complex.h></a>
double creal(double complex z);
float crealf(float complex z);
which expand to integer constant expressions with type int, distinct positive values, and
which are suitable for use in #if preprocessing directives; and
<pre>
which expand to integer constant expressions with type int, distinct positive values, and
which are suitable for use in #if preprocessing directives; and
<pre>
which expands to a modifiable lvalue<sup><a href="#note175"><b>175)</b></a></sup> that has type int, the value of which is set to a
positive error number by several library functions. It is unspecified whether errno is a
macro or an identifier declared with external linkage. If a macro definition is suppressed
which expands to a modifiable lvalue<sup><a href="#note175"><b>175)</b></a></sup> that has type int, the value of which is set to a
positive error number by several library functions. It is unspecified whether errno is a
macro or an identifier declared with external linkage. If a macro definition is suppressed
represents the floating-point status flags collectively, including any status the
implementation associates with the flags.
represents the floating-point status flags collectively, including any status the
implementation associates with the flags.
is defined if and only if the implementation supports the floating-point exception by
means of the functions in 7.6.2.<sup><a href="#note181"><b>181)</b></a></sup> Additional implementation-defined floating-point
exceptions, with macro definitions beginning with FE_ and an uppercase letter, may also
is defined if and only if the implementation supports the floating-point exception by
means of the functions in 7.6.2.<sup><a href="#note181"><b>181)</b></a></sup> Additional implementation-defined floating-point
exceptions, with macro definitions beginning with FE_ and an uppercase letter, may also
is simply the bitwise OR of all floating-point exception macros defined by the
implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
<p><!--para 7 -->
is simply the bitwise OR of all floating-point exception macros defined by the
implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
<p><!--para 7 -->
is defined if and only if the implementation supports getting and setting the represented
rounding direction by means of the fegetround and fesetround functions.
Additional implementation-defined rounding directions, with macro definitions beginning
is defined if and only if the implementation supports getting and setting the represented
rounding direction by means of the fegetround and fesetround functions.
Additional implementation-defined rounding directions, with macro definitions beginning
represents the default floating-point environment -- the one installed at program startup
-- and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
<a href="#7.6"><fenv.h></a> functions that manage the floating-point environment.
represents the default floating-point environment -- the one installed at program startup
-- and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
<a href="#7.6"><fenv.h></a> functions that manage the floating-point environment.
If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note185"><b>185)</b></a></sup>
If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note185"><b>185)</b></a></sup>
<pre>
#include <a href="#7.6"><fenv.h></a>
int fegetexceptflag(fexcept_t *flagp,
<pre>
#include <a href="#7.6"><fenv.h></a>
int fegetexceptflag(fexcept_t *flagp,
<pre>
#include <a href="#7.6"><fenv.h></a>
int fesetexceptflag(const fexcept_t *flagp,
<pre>
#include <a href="#7.6"><fenv.h></a>
int fesetexceptflag(const fexcept_t *flagp,
It declares functions for manipulating greatest-width integers and converting numeric
character strings to greatest-width integers, and it declares the type
<pre>
It declares functions for manipulating greatest-width integers and converting numeric
character strings to greatest-width integers, and it declares the type
<pre>
which is a structure type that is the type of the value returned by the imaxdiv function.
For each type declared in <a href="#7.18"><stdint.h></a>, it defines corresponding macros for conversion
specifiers for use with the formatted input/output functions.<sup><a href="#note190"><b>190)</b></a></sup>
which is a structure type that is the type of the value returned by the imaxdiv function.
For each type declared in <a href="#7.18"><stdint.h></a>, it defines corresponding macros for conversion
specifiers for use with the formatted input/output functions.<sup><a href="#note190"><b>190)</b></a></sup>
PRIoN PRIoLEASTN PRIoFASTN PRIoMAX PRIoPTR
PRIuN PRIuLEASTN PRIuFASTN PRIuMAX PRIuPTR
PRIxN PRIxLEASTN PRIxFASTN PRIxMAX PRIxPTR
PRIoN PRIoLEASTN PRIoFASTN PRIoMAX PRIoPTR
PRIuN PRIuLEASTN PRIuFASTN PRIuMAX PRIuPTR
PRIxN PRIxLEASTN PRIxFASTN PRIxMAX PRIxPTR
The fscanf macros for unsigned integers are:
<p><!--para 6 -->
<pre>
SCNoN SCNoLEASTN SCNoFASTN SCNoMAX SCNoPTR
SCNuN SCNuLEASTN SCNuFASTN SCNuMAX SCNuPTR
The fscanf macros for unsigned integers are:
<p><!--para 6 -->
<pre>
SCNoN SCNoLEASTN SCNoFASTN SCNoMAX SCNoPTR
SCNuN SCNuLEASTN SCNuFASTN SCNuMAX SCNuPTR
For each type that the implementation provides in <a href="#7.18"><stdint.h></a>, the corresponding
fprintf macros shall be defined and the corresponding fscanf macros shall be
defined unless the implementation does not have a suitable fscanf length modifier for
For each type that the implementation provides in <a href="#7.18"><stdint.h></a>, the corresponding
fprintf macros shall be defined and the corresponding fscanf macros shall be
defined unless the implementation does not have a suitable fscanf length modifier for
intmax_t strtoimax(const char * restrict nptr,
char ** restrict endptr, int base);
uintmax_t strtoumax(const char * restrict nptr,
intmax_t strtoimax(const char * restrict nptr,
char ** restrict endptr, int base);
uintmax_t strtoumax(const char * restrict nptr,
intmax_t wcstoimax(const wchar_t * restrict nptr,
wchar_t ** restrict endptr, int base);
uintmax_t wcstoumax(const wchar_t * restrict nptr,
intmax_t wcstoimax(const wchar_t * restrict nptr,
wchar_t ** restrict endptr, int base);
uintmax_t wcstoumax(const wchar_t * restrict nptr,
which contains members related to the formatting of numeric values. The structure shall
contain at least the following members, in any order. The semantics of the members and
their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
which contains members related to the formatting of numeric values. The structure shall
contain at least the following members, in any order. The semantics of the members and
their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
char int_p_sep_by_space; // CHAR_MAX
char int_n_sep_by_space; // CHAR_MAX
char int_p_sign_posn; // CHAR_MAX
char int_p_sep_by_space; // CHAR_MAX
char int_n_sep_by_space; // CHAR_MAX
char int_p_sign_posn; // CHAR_MAX
which expand to integer constant expressions with distinct values, suitable for use as the
first argument to the setlocale function.<sup><a href="#note194"><b>194)</b></a></sup> Additional macro definitions, beginning
with the characters LC_ and an uppercase letter,<sup><a href="#note195"><b>195)</b></a></sup> may also be specified by the
which expand to integer constant expressions with distinct values, suitable for use as the
first argument to the setlocale function.<sup><a href="#note194"><b>194)</b></a></sup> Additional macro definitions, beginning
with the characters LC_ and an uppercase letter,<sup><a href="#note195"><b>195)</b></a></sup> may also be specified by the
1 +$1.25 +$ <a href="#1.25">1.25</a> + $1.25
2 $1.25+ $ <a href="#1.25">1.25</a>+ $1.25 +
3 +$1.25 +$ <a href="#1.25">1.25</a> + $1.25
1 +$1.25 +$ <a href="#1.25">1.25</a> + $1.25
2 $1.25+ $ <a href="#1.25">1.25</a>+ $1.25 +
3 +$1.25 +$ <a href="#1.25">1.25</a> + $1.25
are floating types at least as wide as float and double, respectively, and such that
double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
float_t and double_t are float and double, respectively; if
are floating types at least as wide as float and double, respectively, and such that
double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
float_t and double_t are float and double, respectively; if
expands to a constant expression of type float representing positive or unsigned
infinity, if available; else to a positive constant of type float that overflows at
expands to a constant expression of type float representing positive or unsigned
infinity, if available; else to a positive constant of type float that overflows at
is defined if and only if the implementation supports quiet NaNs for the float type. It
expands to a constant expression of type float representing a quiet NaN.
<p><!--para 6 -->
is defined if and only if the implementation supports quiet NaNs for the float type. It
expands to a constant expression of type float representing a quiet NaN.
<p><!--para 6 -->
represent the mutually exclusive kinds of floating-point values. They expand to integer
constant expressions with distinct values. Additional implementation-defined floating-
point classifications, with macro definitions beginning with FP_ and an uppercase letter,
represent the mutually exclusive kinds of floating-point values. They expand to integer
constant expressions with distinct values. Additional implementation-defined floating-
point classifications, with macro definitions beginning with FP_ and an uppercase letter,
is optionally defined. If defined, it indicates that the fma function generally executes
about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note202"><b>202)</b></a></sup> The
macros
<pre>
FP_FAST_FMAF
is optionally defined. If defined, it indicates that the fma function generally executes
about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note202"><b>202)</b></a></sup> The
macros
<pre>
FP_FAST_FMAF
are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
these macros expand to the integer constant 1.
<p><!--para 8 -->
The macros
<pre>
FP_ILOGB0
are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
these macros expand to the integer constant 1.
<p><!--para 8 -->
The macros
<pre>
FP_ILOGB0
expand to integer constant expressions whose values are returned by ilogb(x) if x is
zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
-INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
expand to integer constant expressions whose values are returned by ilogb(x) if x is
zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
-INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
expands to an expression that has type int and the value MATH_ERRNO,
MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
constant for the duration of the program. It is unspecified whether
expands to an expression that has type int and the value MATH_ERRNO,
MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
constant for the duration of the program. It is unspecified whether
<h6>Description</h6>
<p><!--para 2 -->
The fpclassify macro classifies its argument value as NaN, infinite, normal,
<h6>Description</h6>
<p><!--para 2 -->
The fpclassify macro classifies its argument value as NaN, infinite, normal,
#define fpclassify(x) \
((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) : \
(sizeof (x) == sizeof (double)) ? __fpclassifyd(x) : \
#define fpclassify(x) \
((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) : \
(sizeof (x) == sizeof (double)) ? __fpclassifyd(x) : \
#include <a href="#7.12"><math.h></a>
double atan2(double y, double x);
float atan2f(float y, float x);
#include <a href="#7.12"><math.h></a>
double atan2(double y, double x);
float atan2f(float y, float x);
#include <a href="#7.12"><math.h></a>
double frexp(double value, int *exp);
float frexpf(float value, int *exp);
#include <a href="#7.12"><math.h></a>
double frexp(double value, int *exp);
float frexpf(float value, int *exp);
#include <a href="#7.12"><math.h></a>
double ldexp(double x, int exp);
float ldexpf(float x, int exp);
#include <a href="#7.12"><math.h></a>
double ldexp(double x, int exp);
float ldexpf(float x, int exp);
<h6>Description</h6>
<p><!--para 2 -->
The logb functions extract the exponent of x, as a signed integer value in floating-point
format. If x is subnormal it is treated as though it were normalized; thus, for positive
finite x,
<pre>
<h6>Description</h6>
<p><!--para 2 -->
The logb functions extract the exponent of x, as a signed integer value in floating-point
format. If x is subnormal it is treated as though it were normalized; thus, for positive
finite x,
<pre>
#include <a href="#7.12"><math.h></a>
double modf(double value, double *iptr);
float modff(float value, float *iptr);
#include <a href="#7.12"><math.h></a>
double modf(double value, double *iptr);
float modff(float value, float *iptr);
long double scalbnl(long double x, int n);
double scalbln(double x, long int n);
float scalblnf(float x, long int n);
long double scalbnl(long double x, int n);
double scalbln(double x, long int n);
float scalblnf(float x, long int n);
#include <a href="#7.12"><math.h></a>
double hypot(double x, double y);
float hypotf(float x, float y);
#include <a href="#7.12"><math.h></a>
double hypot(double x, double y);
float hypotf(float x, float y);
#include <a href="#7.12"><math.h></a>
double pow(double x, double y);
float powf(float x, float y);
#include <a href="#7.12"><math.h></a>
double pow(double x, double y);
float powf(float x, float y);
#include <a href="#7.12"><math.h></a>
double nearbyint(double x);
float nearbyintf(float x);
#include <a href="#7.12"><math.h></a>
double nearbyint(double x);
float nearbyintf(float x);
long int lrintl(long double x);
long long int llrint(double x);
long long int llrintf(float x);
long int lrintl(long double x);
long long int llrint(double x);
long long int llrintf(float x);
long int lroundl(long double x);
long long int llround(double x);
long long int llroundf(float x);
long int lroundl(long double x);
long long int llround(double x);
long long int llroundf(float x);
#include <a href="#7.12"><math.h></a>
double fmod(double x, double y);
float fmodf(float x, float y);
#include <a href="#7.12"><math.h></a>
double fmod(double x, double y);
float fmodf(float x, float y);
#include <a href="#7.12"><math.h></a>
double remainder(double x, double y);
float remainderf(float x, float y);
#include <a href="#7.12"><math.h></a>
double remainder(double x, double y);
float remainderf(float x, float y);
double remquo(double x, double y, int *quo);
float remquof(float x, float y, int *quo);
long double remquol(long double x, long double y,
double remquo(double x, double y, int *quo);
float remquof(float x, float y, int *quo);
long double remquol(long double x, long double y,
#include <a href="#7.12"><math.h></a>
double copysign(double x, double y);
float copysignf(float x, float y);
#include <a href="#7.12"><math.h></a>
double copysign(double x, double y);
float copysignf(float x, float y);
#include <a href="#7.12"><math.h></a>
double nan(const char *tagp);
float nanf(const char *tagp);
#include <a href="#7.12"><math.h></a>
double nan(const char *tagp);
float nanf(const char *tagp);
#include <a href="#7.12"><math.h></a>
double nextafter(double x, double y);
float nextafterf(float x, float y);
#include <a href="#7.12"><math.h></a>
double nextafter(double x, double y);
float nextafterf(float x, float y);
#include <a href="#7.12"><math.h></a>
double nexttoward(double x, long double y);
float nexttowardf(float x, long double y);
#include <a href="#7.12"><math.h></a>
double nexttoward(double x, long double y);
float nexttowardf(float x, long double y);
#include <a href="#7.12"><math.h></a>
double fdim(double x, double y);
float fdimf(float x, float y);
#include <a href="#7.12"><math.h></a>
double fdim(double x, double y);
float fdimf(float x, float y);
#include <a href="#7.12"><math.h></a>
double fmax(double x, double y);
float fmaxf(float x, float y);
#include <a href="#7.12"><math.h></a>
double fmax(double x, double y);
float fmaxf(float x, float y);
#include <a href="#7.12"><math.h></a>
double fmin(double x, double y);
float fminf(float x, float y);
#include <a href="#7.12"><math.h></a>
double fmin(double x, double y);
float fminf(float x, float y);
double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y,
double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y,
which is an array type suitable for holding the information needed to restore a calling
environment. The environment of a call to the setjmp macro consists of information
sufficient for a call to the longjmp function to return execution to the correct block and
which is an array type suitable for holding the information needed to restore a calling
environment. The environment of a call to the setjmp macro consists of information
sufficient for a call to the longjmp function to return execution to the correct block and
If the return is from a direct invocation, the setjmp macro returns the value zero. If the
return is from a call to the longjmp function, the setjmp macro returns a nonzero
value.
If the return is from a direct invocation, the setjmp macro returns the value zero. If the
return is from a call to the longjmp function, the setjmp macro returns a nonzero
value.
{
int b[n]; // b may remain allocated
longjmp(buf, 2); // might cause memory loss
{
int b[n]; // b may remain allocated
longjmp(buf, 2); // might cause memory loss
which is the (possibly volatile-qualified) integer type of an object that can be accessed as
an atomic entity, even in the presence of asynchronous interrupts.
<p><!--para 3 -->
which is the (possibly volatile-qualified) integer type of an object that can be accessed as
an atomic entity, even in the presence of asynchronous interrupts.
<p><!--para 3 -->
which expand to constant expressions with distinct values that have type compatible with
the second argument to, and the return value of, the signal function, and whose values
compare unequal to the address of any declarable function; and the following, which
which expand to constant expressions with distinct values that have type compatible with
the second argument to, and the return value of, the signal function, and whose values
compare unequal to the address of any declarable function; and the following, which
SIGILL detection of an invalid function image, such as an invalid instruction
SIGINT receipt of an interactive attention signal
SIGSEGV an invalid access to storage
SIGILL detection of an invalid function image, such as an invalid instruction
SIGINT receipt of an interactive attention signal
SIGSEGV an invalid access to storage
An implementation need not generate any of these signals, except as a result of explicit
calls to the raise function. Additional signals and pointers to undeclarable functions,
with macro definitions beginning, respectively, with the letters SIG and an uppercase
An implementation need not generate any of these signals, except as a result of explicit
calls to the raise function. Additional signals and pointers to undeclarable functions,
with macro definitions beginning, respectively, with the letters SIG and an uppercase
is executed for all other signals defined by the implementation.
<p><!--para 7 -->
The implementation shall behave as if no library function calls the signal function.
is executed for all other signals defined by the implementation.
<p><!--para 7 -->
The implementation shall behave as if no library function calls the signal function.
which is an object type suitable for holding information needed by the macros
va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
desired, the called function shall declare an object (generally referred to as ap in this
which is an object type suitable for holding information needed by the macros
va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
desired, the called function shall declare an object (generally referred to as ap in this
which expands to the integer constant 1.
<p><!--para 4 -->
Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
which expands to the integer constant 1.
<p><!--para 4 -->
Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
which is an integer type whose range of values can represent distinct codes for all
members of the largest extended character set specified among the supported locales; the
null character shall have the code value zero. Each member of the basic character set
which is an integer type whose range of values can represent distinct codes for all
members of the largest extended character set specified among the supported locales; the
null character shall have the code value zero. Each member of the basic character set
which expands to an integer constant expression that has type size_t, the value of
which is the offset in bytes, to the structure member (designated by member-designator),
from the beginning of its structure (designated by type). The type and member designator
shall be such that given
<pre>
which expands to an integer constant expression that has type size_t, the value of
which is the offset in bytes, to the structure member (designated by member-designator),
from the beginning of its structure (designated by type). The type and member designator
shall be such that given
<pre>
then the expression &(t.member-designator) evaluates to an address constant. (If the
specified member is a bit-field, the behavior is undefined.)
then the expression &(t.member-designator) evaluates to an address constant. (If the
specified member is a bit-field, the behavior is undefined.)
<p><!--para 4 -->
The types used for size_t and ptrdiff_t should not have an integer conversion rank
greater than that of signed long int unless the implementation supports objects
<p><!--para 4 -->
The types used for size_t and ptrdiff_t should not have an integer conversion rank
greater than that of signed long int unless the implementation supports objects
int_least8_t uint_least8_t
int_least16_t uint_least16_t
int_least32_t uint_least32_t
int_least8_t uint_least8_t
int_least16_t uint_least16_t
int_least32_t uint_least32_t
All other types of this form are optional.
<h5><a name="7.18.1.3" href="#7.18.1.3">7.18.1.3 Fastest minimum-width integer types</a></h5>
All other types of this form are optional.
<h5><a name="7.18.1.3" href="#7.18.1.3">7.18.1.3 Fastest minimum-width integer types</a></h5>
pointer to void can be converted to this type, then converted back to pointer to void,
and the result will compare equal to the original pointer:
<pre>
pointer to void can be converted to this type, then converted back to pointer to void,
and the result will compare equal to the original pointer:
<pre>
The following type designates an unsigned integer type with the property that any valid
pointer to void can be converted to this type, then converted back to pointer to void,
and the result will compare equal to the original pointer:
<pre>
The following type designates an unsigned integer type with the property that any valid
pointer to void can be converted to this type, then converted back to pointer to void,
and the result will compare equal to the original pointer:
<pre>
These types are optional.
<h5><a name="7.18.1.5" href="#7.18.1.5">7.18.1.5 Greatest-width integer types</a></h5>
These types are optional.
<h5><a name="7.18.1.5" href="#7.18.1.5">7.18.1.5 Greatest-width integer types</a></h5>
The following type designates an unsigned integer type capable of representing any value
of any unsigned integer type:
<pre>
The following type designates an unsigned integer type capable of representing any value
of any unsigned integer type:
<pre>
These types are required.
<h4><a name="7.18.2" href="#7.18.2">7.18.2 Limits of specified-width integer types</a></h4>
These types are required.
<h4><a name="7.18.2" href="#7.18.2">7.18.2 Limits of specified-width integer types</a></h4>
The following macro expands to an integer constant expression having the value specified
by its argument and the type intmax_t:
<pre>
The following macro expands to an integer constant expression having the value specified
by its argument and the type intmax_t:
<pre>
The following macro expands to an integer constant expression having the value specified
by its argument and the type uintmax_t:
<!--page 274 -->
<pre>
The following macro expands to an integer constant expression having the value specified
by its argument and the type uintmax_t:
<!--page 274 -->
<pre>
which is an object type capable of recording all the information needed to control a
stream, including its file position indicator, a pointer to its associated buffer (if any), an
error indicator that records whether a read/write error has occurred, and an end-of-file
indicator that records whether the end of the file has been reached; and
<pre>
which is an object type capable of recording all the information needed to control a
stream, including its file position indicator, a pointer to its associated buffer (if any), an
error indicator that records whether a read/write error has occurred, and an end-of-file
indicator that records whether the end of the file has been reached; and
<pre>
which is an object type other than an array type capable of recording all the information
needed to specify uniquely every position within a file.
<p><!--para 3 -->
which is an object type other than an array type capable of recording all the information
needed to specify uniquely every position within a file.
<p><!--para 3 -->
which expand to integer constant expressions with distinct values, suitable for use as the
third argument to the setvbuf function;
<pre>
which expand to integer constant expressions with distinct values, suitable for use as the
third argument to the setvbuf function;
<pre>
which expands to an integer constant expression, with type int and a negative value, that
is returned by several functions to indicate end-of-file, that is, no more input from a
stream;
<pre>
which expands to an integer constant expression, with type int and a negative value, that
is returned by several functions to indicate end-of-file, that is, no more input from a
stream;
<pre>
which expands to an integer constant expression that is the minimum number of files that
the implementation guarantees can be open simultaneously;
<pre>
which expands to an integer constant expression that is the minimum number of files that
the implementation guarantees can be open simultaneously;
<pre>
which expands to an integer constant expression that is the size needed for an array of
char large enough to hold the longest file name string that the implementation
<!--page 275 -->
guarantees can be opened;<sup><a href="#note231"><b>231)</b></a></sup>
<pre>
which expands to an integer constant expression that is the size needed for an array of
char large enough to hold the longest file name string that the implementation
<!--page 275 -->
guarantees can be opened;<sup><a href="#note231"><b>231)</b></a></sup>
<pre>
which expands to an integer constant expression that is the size needed for an array of
char large enough to hold a temporary file name string generated by the tmpnam
function;
<pre>
SEEK_CUR
SEEK_END
which expands to an integer constant expression that is the size needed for an array of
char large enough to hold a temporary file name string generated by the tmpnam
function;
<pre>
SEEK_CUR
SEEK_END
which expand to integer constant expressions with distinct values, suitable for use as the
third argument to the fseek function;
<pre>
which expand to integer constant expressions with distinct values, suitable for use as the
third argument to the fseek function;
<pre>
which expands to an integer constant expression that is the maximum number of unique
file names that can be generated by the tmpnam function;
<pre>
stderr
stdin
which expands to an integer constant expression that is the maximum number of unique
file names that can be generated by the tmpnam function;
<pre>
stderr
stdin
which are expressions of type ''pointer to FILE'' that point to the FILE objects
associated, respectively, with the standard error, input, and output streams.
<p><!--para 4 -->
which are expressions of type ''pointer to FILE'' that point to the FILE objects
associated, respectively, with the standard error, input, and output streams.
<p><!--para 4 -->
value of this mbstate_t object as part of the value of the fpos_t object. A later
successful call to fsetpos using the same stored fpos_t value restores the value of
the associated mbstate_t object as well as the position within the controlled stream.
value of this mbstate_t object as part of the value of the fpos_t object. A later
successful call to fsetpos using the same stored fpos_t value restores the value of
the associated mbstate_t object as well as the position within the controlled stream.
<p><!--para 7 -->
An implementation shall support text files with lines containing at least 254 characters,
including the terminating new-line character. The value of the macro BUFSIZ shall be at
<p><!--para 7 -->
An implementation shall support text files with lines containing at least 254 characters,
including the terminating new-line character. The value of the macro BUFSIZ shall be at
multibyte character. The wide character input/output functions and the byte input/output
functions store the value of the macro EILSEQ in errno if and only if an encoding error
occurs.
multibyte character. The wide character input/output functions and the byte input/output
functions store the value of the macro EILSEQ in errno if and only if an encoding error
occurs.
<h6>Description</h6>
<p><!--para 2 -->
The tmpfile function creates a temporary binary file that is different from any other
existing file and that will automatically be removed when it is closed or at program
termination. If the program terminates abnormally, whether an open temporary file is
removed is implementation-defined. The file is opened for update with "wb+" mode.
<h6>Description</h6>
<p><!--para 2 -->
The tmpfile function creates a temporary binary file that is different from any other
existing file and that will automatically be removed when it is closed or at program
termination. If the program terminates abnormally, whether an open temporary file is
removed is implementation-defined. The file is opened for update with "wb+" mode.
<p><!--para 3 -->
It should be possible to open at least TMP_MAX temporary files during the lifetime of the
program (this limit may be shared with tmpnam) and there should be no limit on the
<p><!--para 3 -->
It should be possible to open at least TMP_MAX temporary files during the lifetime of the
program (this limit may be shared with tmpnam) and there should be no limit on the
function may modify the same object). If the argument is not a null pointer, it is assumed
to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
in that array and returns the argument as its value.
function may modify the same object). If the argument is not a null pointer, it is assumed
to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
in that array and returns the argument as its value.
<pre>
#include <a href="#7.19"><stdio.h></a>
FILE *fopen(const char * restrict filename,
<pre>
#include <a href="#7.19"><stdio.h></a>
FILE *fopen(const char * restrict filename,
#include <a href="#7.19"><stdio.h></a>
FILE *freopen(const char * restrict filename,
const char * restrict mode,
#include <a href="#7.19"><stdio.h></a>
FILE *freopen(const char * restrict filename,
const char * restrict mode,
<pre>
#include <a href="#7.19"><stdio.h></a>
void setbuf(FILE * restrict stream,
<pre>
#include <a href="#7.19"><stdio.h></a>
void setbuf(FILE * restrict stream,
#include <a href="#7.19"><stdio.h></a>
int setvbuf(FILE * restrict stream,
char * restrict buf,
#include <a href="#7.19"><stdio.h></a>
int setvbuf(FILE * restrict stream,
char * restrict buf,
<pre>
#include <a href="#7.19"><stdio.h></a>
int fprintf(FILE * restrict stream,
<pre>
#include <a href="#7.19"><stdio.h></a>
int fprintf(FILE * restrict stream,
<p><!--para 11 -->
For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
to a hexadecimal floating number with the given precision.
<p><!--para 11 -->
For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
to a hexadecimal floating number with the given precision.
<p><!--para 12 -->
For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
representable in the given precision, the result should be one of the two adjacent numbers
<p><!--para 12 -->
For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
representable in the given precision, the result should be one of the two adjacent numbers
<p><!--para 14 -->
The fprintf function returns the number of characters transmitted, or a negative value
if an output or encoding error occurred.
<p><!--para 14 -->
The fprintf function returns the number of characters transmitted, or a negative value
if an output or encoding error occurred.
int day, hour, min;
fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",
weekday, month, day, hour, min);
int day, hour, min;
fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",
weekday, month, day, hour, min);
fprintf(stdout, "|%13.10ls|\n", wstr);
fprintf(stdout, "|%13.11ls|\n", wstr);
fprintf(stdout, "|%13.15ls|\n", &wstr[2]);
fprintf(stdout, "|%13.10ls|\n", wstr);
fprintf(stdout, "|%13.11ls|\n", wstr);
fprintf(stdout, "|%13.15ls|\n", &wstr[2]);
<pre>
#include <a href="#7.19"><stdio.h></a>
int fscanf(FILE * restrict stream,
<pre>
#include <a href="#7.19"><stdio.h></a>
int fscanf(FILE * restrict stream,
#include <a href="#7.19"><stdio.h></a>
/* ... */
int n, i; float x; char name[50];
#include <a href="#7.19"><stdio.h></a>
/* ... */
int n, i; float x; char name[50];
- n = fscanf(stdin, "%d%f%s", &i, &x, name);</pre>
+ n = fscanf(stdin, "%d%f%s", &i, &x, name);
+</pre>
will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
thompson\0.
will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
thompson\0.
- fscanf(stdin, "%2d%f%*d %[0123456789]", &i, &x, name);</pre>
+ fscanf(stdin, "%2d%f%*d %[0123456789]", &i, &x, name);
+</pre>
will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
sequence 56\0. The next character read from the input stream will be a.
will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
sequence 56\0. The next character read from the input stream will be a.
do {
count = fscanf(stdin, "%f%20s of %20s", &quant, units, item);
fscanf(stdin,"%*[^\n]");
do {
count = fscanf(stdin, "%f%20s of %20s", &quant, units, item);
fscanf(stdin,"%*[^\n]");
the execution of the above example will be analogous to the following assignments:
<pre>
quant = 2; strcpy(units, "quarts"); strcpy(item, "oil");
the execution of the above example will be analogous to the following assignments:
<pre>
quant = 2; strcpy(units, "quarts"); strcpy(item, "oil");
quant = 10.0; strcpy(units, "LBS"); strcpy(item, "dirt");
count = 3;
count = 0; // "100e" fails to match "%f"
quant = 10.0; strcpy(units, "LBS"); strcpy(item, "dirt");
count = 3;
count = 0; // "100e" fails to match "%f"
- i = sscanf("123", "%d%n%n%d", &d1, &n1, &n2, &d2);</pre>
+ i = sscanf("123", "%d%n%n%d", &d1, &n1, &n2, &d2);
+</pre>
the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure the value
of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure the value
of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
str will contain (uparrow) X Y(downarrow)\0 assuming that none of the bytes of the shift sequences (or of the multibyte
characters, in the more general case) appears to be a single-byte white-space character.
<p><!--para 24 -->
str will contain (uparrow) X Y(downarrow)\0 assuming that none of the bytes of the shift sequences (or of the multibyte
characters, in the more general case) appears to be a single-byte white-space character.
<p><!--para 24 -->
with the same input line, wstr will contain the two wide characters that correspond to X and Y and a
terminating null wide character.
<p><!--para 25 -->
with the same input line, wstr will contain the two wide characters that correspond to X and Y and a
terminating null wide character.
<p><!--para 25 -->
with the same input line, zero will again be returned, but stdin will be left with a partially consumed
multibyte character.
with the same input line, zero will again be returned, but stdin will be left with a partially consumed
multibyte character.
<pre>
#include <a href="#7.19"><stdio.h></a>
int snprintf(char * restrict s, size_t n,
<pre>
#include <a href="#7.19"><stdio.h></a>
int snprintf(char * restrict s, size_t n,
<pre>
#include <a href="#7.19"><stdio.h></a>
int sprintf(char * restrict s,
<pre>
#include <a href="#7.19"><stdio.h></a>
int sprintf(char * restrict s,
<pre>
#include <a href="#7.19"><stdio.h></a>
int sscanf(const char * restrict s,
<pre>
#include <a href="#7.19"><stdio.h></a>
int sscanf(const char * restrict s,
#include <a href="#7.19"><stdio.h></a>
int vfprintf(FILE * restrict stream,
const char * restrict format,
#include <a href="#7.19"><stdio.h></a>
int vfprintf(FILE * restrict stream,
const char * restrict format,
// print out remainder of message
vfprintf(stderr, format, args);
va_end(args);
// print out remainder of message
vfprintf(stderr, format, args);
va_end(args);
#include <a href="#7.19"><stdio.h></a>
int vfscanf(FILE * restrict stream,
const char * restrict format,
#include <a href="#7.19"><stdio.h></a>
int vfscanf(FILE * restrict stream,
const char * restrict format,
#include <a href="#7.15"><stdarg.h></a>
#include <a href="#7.19"><stdio.h></a>
int vprintf(const char * restrict format,
#include <a href="#7.15"><stdarg.h></a>
#include <a href="#7.19"><stdio.h></a>
int vprintf(const char * restrict format,
#include <a href="#7.15"><stdarg.h></a>
#include <a href="#7.19"><stdio.h></a>
int vscanf(const char * restrict format,
#include <a href="#7.15"><stdarg.h></a>
#include <a href="#7.19"><stdio.h></a>
int vscanf(const char * restrict format,
#include <a href="#7.19"><stdio.h></a>
int vsnprintf(char * restrict s, size_t n,
const char * restrict format,
#include <a href="#7.19"><stdio.h></a>
int vsnprintf(char * restrict s, size_t n,
const char * restrict format,
#include <a href="#7.19"><stdio.h></a>
int vsprintf(char * restrict s,
const char * restrict format,
#include <a href="#7.19"><stdio.h></a>
int vsprintf(char * restrict s,
const char * restrict format,
#include <a href="#7.19"><stdio.h></a>
int vsscanf(const char * restrict s,
const char * restrict format,
#include <a href="#7.19"><stdio.h></a>
int vsscanf(const char * restrict s,
const char * restrict format,
<pre>
#include <a href="#7.19"><stdio.h></a>
char *fgets(char * restrict s, int n,
<pre>
#include <a href="#7.19"><stdio.h></a>
char *fgets(char * restrict s, int n,
<pre>
#include <a href="#7.19"><stdio.h></a>
int fputs(const char * restrict s,
<pre>
#include <a href="#7.19"><stdio.h></a>
int fputs(const char * restrict s,
#include <a href="#7.19"><stdio.h></a>
size_t fread(void * restrict ptr,
size_t size, size_t nmemb,
#include <a href="#7.19"><stdio.h></a>
size_t fread(void * restrict ptr,
size_t size, size_t nmemb,
#include <a href="#7.19"><stdio.h></a>
size_t fwrite(const void * restrict ptr,
size_t size, size_t nmemb,
#include <a href="#7.19"><stdio.h></a>
size_t fwrite(const void * restrict ptr,
size_t size, size_t nmemb,
<pre>
#include <a href="#7.19"><stdio.h></a>
int fgetpos(FILE * restrict stream,
<pre>
#include <a href="#7.19"><stdio.h></a>
int fgetpos(FILE * restrict stream,
<h6>Description</h6>
<p><!--para 2 -->
The rewind function sets the file position indicator for the stream pointed to by
stream to the beginning of the file. It is equivalent to
<pre>
<h6>Description</h6>
<p><!--para 2 -->
The rewind function sets the file position indicator for the stream pointed to by
stream to the beginning of the file. It is equivalent to
<pre>
which is a structure type that is the type of the value returned by the lldiv function.
<p><!--para 3 -->
The macros defined are NULL (described in <a href="#7.17">7.17</a>);
<pre>
which is a structure type that is the type of the value returned by the lldiv function.
<p><!--para 3 -->
The macros defined are NULL (described in <a href="#7.17">7.17</a>);
<pre>
which expand to integer constant expressions that can be used as the argument to the
exit function to return unsuccessful or successful termination status, respectively, to the
host environment;
<pre>
which expand to integer constant expressions that can be used as the argument to the
exit function to return unsuccessful or successful termination status, respectively, to the
host environment;
<pre>
which expands to a positive integer expression with type size_t that is the maximum
number of bytes in a multibyte character for the extended character set specified by the
current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
which expands to a positive integer expression with type size_t that is the maximum
number of bytes in a multibyte character for the extended character set specified by the
current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
<h6>Description</h6>
<p><!--para 2 -->
The atof function converts the initial portion of the string pointed to by nptr to
double representation. Except for the behavior on error, it is equivalent to
<pre>
<h6>Description</h6>
<p><!--para 2 -->
The atof function converts the initial portion of the string pointed to by nptr to
double representation. Except for the behavior on error, it is equivalent to
<pre>
#include <a href="#7.20"><stdlib.h></a>
int atoi(const char *nptr);
long int atol(const char *nptr);
#include <a href="#7.20"><stdlib.h></a>
int atoi(const char *nptr);
long int atol(const char *nptr);
<pre>
atoi: (int)strtol(nptr, (char **)NULL, 10)
atol: strtol(nptr, (char **)NULL, 10)
<pre>
atoi: (int)strtol(nptr, (char **)NULL, 10)
atol: strtol(nptr, (char **)NULL, 10)
float strtof(const char * restrict nptr,
char ** restrict endptr);
long double strtold(const char * restrict nptr,
float strtof(const char * restrict nptr,
char ** restrict endptr);
long double strtold(const char * restrict nptr,
</ul>
The subject sequence is defined as the longest initial subsequence of the input string,
starting with the first non-white-space character, that is of the expected form. The subject
</ul>
The subject sequence is defined as the longest initial subsequence of the input string,
starting with the first non-white-space character, that is of the expected form. The subject
If the subject sequence is empty or does not have the expected form, no conversion is
performed; the value of nptr is stored in the object pointed to by endptr, provided
that endptr is not a null pointer.
If the subject sequence is empty or does not have the expected form, no conversion is
performed; the value of nptr is stored in the object pointed to by endptr, provided
that endptr is not a null pointer.
<p><!--para 8 -->
If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
the result is not exactly representable, the result should be one of the two numbers in the
<p><!--para 8 -->
If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
the result is not exactly representable, the result should be one of the two numbers in the
unsigned long long int strtoull(
const char * restrict nptr,
char ** restrict endptr,
unsigned long long int strtoull(
const char * restrict nptr,
char ** restrict endptr,
<h6>Description</h6>
<p><!--para 2 -->
The strtol, strtoll, strtoul, and strtoull functions convert the initial
<h6>Description</h6>
<p><!--para 2 -->
The strtol, strtoll, strtoul, and strtoull functions convert the initial
<h6>Description</h6>
<p><!--para 2 -->
The atexit function registers the function pointed to by func, to be called without
arguments at normal program termination.
<h6>Description</h6>
<p><!--para 2 -->
The atexit function registers the function pointed to by func, to be called without
arguments at normal program termination.
#include <a href="#7.20"><stdlib.h></a>
void *bsearch(const void *key, const void *base,
size_t nmemb, size_t size,
#include <a href="#7.20"><stdlib.h></a>
void *bsearch(const void *key, const void *base,
size_t nmemb, size_t size,
<pre>
#include <a href="#7.20"><stdlib.h></a>
void qsort(void *base, size_t nmemb, size_t size,
<pre>
#include <a href="#7.20"><stdlib.h></a>
void qsort(void *base, size_t nmemb, size_t size,
#include <a href="#7.20"><stdlib.h></a>
div_t div(int numer, int denom);
ldiv_t ldiv(long int numer, long int denom);
#include <a href="#7.20"><stdlib.h></a>
div_t div(int numer, int denom);
ldiv_t ldiv(long int numer, long int denom);
<h6>Description</h6>
<p><!--para 2 -->
The div, ldiv, and lldiv, functions compute numer / denom and numer %
<h6>Description</h6>
<p><!--para 2 -->
The div, ldiv, and lldiv, functions compute numer / denom and numer %
#include <a href="#7.20"><stdlib.h></a>
int mbtowc(wchar_t * restrict pwc,
const char * restrict s,
#include <a href="#7.20"><stdlib.h></a>
int mbtowc(wchar_t * restrict pwc,
const char * restrict s,
#include <a href="#7.20"><stdlib.h></a>
size_t mbstowcs(wchar_t * restrict pwcs,
const char * restrict s,
#include <a href="#7.20"><stdlib.h></a>
size_t mbstowcs(wchar_t * restrict pwcs,
const char * restrict s,
#include <a href="#7.20"><stdlib.h></a>
size_t wcstombs(char * restrict s,
const wchar_t * restrict pwcs,
#include <a href="#7.20"><stdlib.h></a>
size_t wcstombs(char * restrict s,
const wchar_t * restrict pwcs,
#include <a href="#7.21"><string.h></a>
void *memcpy(void * restrict s1,
const void * restrict s2,
#include <a href="#7.21"><string.h></a>
void *memcpy(void * restrict s1,
const void * restrict s2,
<pre>
#include <a href="#7.21"><string.h></a>
char *strcpy(char * restrict s1,
<pre>
#include <a href="#7.21"><string.h></a>
char *strcpy(char * restrict s1,
#include <a href="#7.21"><string.h></a>
char *strncpy(char * restrict s1,
const char * restrict s2,
#include <a href="#7.21"><string.h></a>
char *strncpy(char * restrict s1,
const char * restrict s2,
<pre>
#include <a href="#7.21"><string.h></a>
char *strcat(char * restrict s1,
<pre>
#include <a href="#7.21"><string.h></a>
char *strcat(char * restrict s1,
#include <a href="#7.21"><string.h></a>
char *strncat(char * restrict s1,
const char * restrict s2,
#include <a href="#7.21"><string.h></a>
char *strncat(char * restrict s1,
const char * restrict s2,
#include <a href="#7.21"><string.h></a>
size_t strxfrm(char * restrict s1,
const char * restrict s2,
#include <a href="#7.21"><string.h></a>
size_t strxfrm(char * restrict s1,
const char * restrict s2,
EXAMPLE The value of the following expression is the size of the array needed to hold the
transformation of the string pointed to by s.
<pre>
EXAMPLE The value of the following expression is the size of the array needed to hold the
transformation of the string pointed to by s.
<pre>
<pre>
#include <a href="#7.21"><string.h></a>
char *strtok(char * restrict s1,
<pre>
#include <a href="#7.21"><string.h></a>
char *strtok(char * restrict s1,
t = strtok(str, "?"); // t points to the token "a"
t = strtok(NULL, ","); // t points to the token "??b"
t = strtok(NULL, "#,"); // t points to the token "c"
t = strtok(str, "?"); // t points to the token "a"
t = strtok(NULL, ","); // t points to the token "??b"
t = strtok(NULL, "#,"); // t points to the token "c"
If at least one argument for a generic parameter is complex, then use of the macro invokes
a complex function; otherwise, use of the macro invokes a real function.
<p><!--para 5 -->
If at least one argument for a generic parameter is complex, then use of the macro invokes
a complex function; otherwise, use of the macro invokes a real function.
<p><!--para 5 -->
If all arguments for generic parameters are real, then use of the macro invokes a real
function; otherwise, use of the macro results in undefined behavior.
<p><!--para 6 -->
If all arguments for generic parameters are real, then use of the macro invokes a real
function; otherwise, use of the macro results in undefined behavior.
<p><!--para 6 -->
Use of the macro with any real or complex argument invokes a complex function.
<p><!--para 7 -->
EXAMPLE With the declarations
Use of the macro with any real or complex argument invokes a complex function.
<p><!--para 7 -->
EXAMPLE With the declarations
which expands to an expression with type clock_t (described below) that is the
number per second of the value returned by the clock function.
<p><!--para 3 -->
The types declared are size_t (described in <a href="#7.17">7.17</a>);
<pre>
which expands to an expression with type clock_t (described below) that is the
number per second of the value returned by the clock function.
<p><!--para 3 -->
The types declared are size_t (described in <a href="#7.17">7.17</a>);
<pre>
which holds the components of a calendar time, called the broken-down time.
<p><!--para 4 -->
The range and precision of times representable in clock_t and time_t are
which holds the components of a calendar time, called the broken-down time.
<p><!--para 4 -->
The range and precision of times representable in clock_t and time_t are
int tm_year; // years since 1900
int tm_wday; // days since Sunday -- [0, 6]
int tm_yday; // days since January 1 -- [0, 365]
int tm_year; // years since 1900
int tm_wday; // days since Sunday -- [0, 6]
int tm_yday; // days since January 1 -- [0, 365]
"Thursday", "Friday", "Saturday", "-unknown-"
};
struct tm time_str;
"Thursday", "Friday", "Saturday", "-unknown-"
};
struct tm time_str;
<h6>Description</h6>
<p><!--para 2 -->
The asctime function converts the broken-down time in the structure pointed to by
timeptr into a string in the form
<!--page 354 -->
<pre>
<h6>Description</h6>
<p><!--para 2 -->
The asctime function converts the broken-down time in the structure pointed to by
timeptr into a string in the form
<!--page 354 -->
<pre>
<h6>Description</h6>
<p><!--para 2 -->
The ctime function converts the calendar time pointed to by timer to local time in the
form of a string. It is equivalent to
<pre>
<h6>Description</h6>
<p><!--para 2 -->
The ctime function converts the calendar time pointed to by timer to local time in the
form of a string. It is equivalent to
<pre>
size_t strftime(char * restrict s,
size_t maxsize,
const char * restrict format,
size_t strftime(char * restrict s,
size_t maxsize,
const char * restrict format,
which is an object type other than an array type that can hold the conversion state
information necessary to convert between sequences of multibyte characters and wide
characters;
<pre>
which is an object type other than an array type that can hold the conversion state
information necessary to convert between sequences of multibyte characters and wide
characters;
<pre>
which is an integer type unchanged by default argument promotions that can hold any
value corresponding to members of the extended character set, as well as at least one
value that does not correspond to any member of the extended character set (see WEOF
below);<sup><a href="#note278"><b>278)</b></a></sup> and
<pre>
which is an integer type unchanged by default argument promotions that can hold any
value corresponding to members of the extended character set, as well as at least one
value that does not correspond to any member of the extended character set (see WEOF
below);<sup><a href="#note278"><b>278)</b></a></sup> and
<pre>
which is declared as an incomplete structure type (the contents are described in <a href="#7.23.1">7.23.1</a>).
<p><!--para 3 -->
The macros defined are NULL (described in <a href="#7.17">7.17</a>); WCHAR_MIN and WCHAR_MAX
(described in <a href="#7.18.3">7.18.3</a>); and
<pre>
which is declared as an incomplete structure type (the contents are described in <a href="#7.23.1">7.23.1</a>).
<p><!--para 3 -->
The macros defined are NULL (described in <a href="#7.17">7.17</a>); WCHAR_MIN and WCHAR_MAX
(described in <a href="#7.18.3">7.18.3</a>); and
<pre>
which expands to a constant expression of type wint_t whose value does not
correspond to any member of the extended character set.<sup><a href="#note279"><b>279)</b></a></sup> It is accepted (and returned)
by several functions in this subclause to indicate end-of-file, that is, no more input from a
which expands to a constant expression of type wint_t whose value does not
correspond to any member of the extended character set.<sup><a href="#note279"><b>279)</b></a></sup> It is accepted (and returned)
by several functions in this subclause to indicate end-of-file, that is, no more input from a
#include <a href="#7.19"><stdio.h></a>
#include <a href="#7.24"><wchar.h></a>
int fwprintf(FILE * restrict stream,
#include <a href="#7.19"><stdio.h></a>
#include <a href="#7.24"><wchar.h></a>
int fwprintf(FILE * restrict stream,
<p><!--para 11 -->
For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
to a hexadecimal floating number with the given precision.
<p><!--para 11 -->
For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
to a hexadecimal floating number with the given precision.
<p><!--para 12 -->
For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
representable in the given precision, the result should be one of the two adjacent numbers
<p><!--para 12 -->
For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
representable in the given precision, the result should be one of the two adjacent numbers
int day, hour, min;
fwprintf(stdout, L"%ls, %ls %d, %.2d:%.2d\n",
weekday, month, day, hour, min);
int day, hour, min;
fwprintf(stdout, L"%ls, %ls %d, %.2d:%.2d\n",
weekday, month, day, hour, min);
<p><b> Forward references</b>: the btowc function (<a href="#7.24.6.1.1">7.24.6.1.1</a>), the mbrtowc function
(<a href="#7.24.6.3.2">7.24.6.3.2</a>).
<p><b> Forward references</b>: the btowc function (<a href="#7.24.6.1.1">7.24.6.1.1</a>), the mbrtowc function
(<a href="#7.24.6.3.2">7.24.6.3.2</a>).
#include <a href="#7.19"><stdio.h></a>
#include <a href="#7.24"><wchar.h></a>
int fwscanf(FILE * restrict stream,
#include <a href="#7.19"><stdio.h></a>
#include <a href="#7.24"><wchar.h></a>
int fwscanf(FILE * restrict stream,
#include <a href="#7.24"><wchar.h></a>
/* ... */
int n, i; float x; wchar_t name[50];
#include <a href="#7.24"><wchar.h></a>
/* ... */
int n, i; float x; wchar_t name[50];
- n = fwscanf(stdin, L"%d%f%ls", &i, &x, name);</pre>
+ n = fwscanf(stdin, L"%d%f%ls", &i, &x, name);
+</pre>
will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
thompson\0.
will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
thompson\0.
- fwscanf(stdin, L"%2d%f%*d %lf", &i, &x, &y);</pre>
+ fwscanf(stdin, L"%2d%f%*d %lf", &i, &x, &y);
+</pre>
will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
56.0. The next wide character read from the input stream will be a.
will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
56.0. The next wide character read from the input stream will be a.
#include <a href="#7.24"><wchar.h></a>
int swprintf(wchar_t * restrict s,
size_t n,
#include <a href="#7.24"><wchar.h></a>
int swprintf(wchar_t * restrict s,
size_t n,
<pre>
#include <a href="#7.24"><wchar.h></a>
int swscanf(const wchar_t * restrict s,
<pre>
#include <a href="#7.24"><wchar.h></a>
int swscanf(const wchar_t * restrict s,
#include <a href="#7.24"><wchar.h></a>
int vfwprintf(FILE * restrict stream,
const wchar_t * restrict format,
#include <a href="#7.24"><wchar.h></a>
int vfwprintf(FILE * restrict stream,
const wchar_t * restrict format,
// print out remainder of message
vfwprintf(stderr, format, args);
va_end(args);
// print out remainder of message
vfwprintf(stderr, format, args);
va_end(args);
#include <a href="#7.24"><wchar.h></a>
int vfwscanf(FILE * restrict stream,
const wchar_t * restrict format,
#include <a href="#7.24"><wchar.h></a>
int vfwscanf(FILE * restrict stream,
const wchar_t * restrict format,
int vswprintf(wchar_t * restrict s,
size_t n,
const wchar_t * restrict format,
int vswprintf(wchar_t * restrict s,
size_t n,
const wchar_t * restrict format,
#include <a href="#7.24"><wchar.h></a>
int vswscanf(const wchar_t * restrict s,
const wchar_t * restrict format,
#include <a href="#7.24"><wchar.h></a>
int vswscanf(const wchar_t * restrict s,
const wchar_t * restrict format,
#include <a href="#7.15"><stdarg.h></a>
#include <a href="#7.24"><wchar.h></a>
int vwprintf(const wchar_t * restrict format,
#include <a href="#7.15"><stdarg.h></a>
#include <a href="#7.24"><wchar.h></a>
int vwprintf(const wchar_t * restrict format,
#include <a href="#7.15"><stdarg.h></a>
#include <a href="#7.24"><wchar.h></a>
int vwscanf(const wchar_t * restrict format,
#include <a href="#7.15"><stdarg.h></a>
#include <a href="#7.24"><wchar.h></a>
int vwscanf(const wchar_t * restrict format,
#include <a href="#7.19"><stdio.h></a>
#include <a href="#7.24"><wchar.h></a>
wchar_t *fgetws(wchar_t * restrict s,
#include <a href="#7.19"><stdio.h></a>
#include <a href="#7.24"><wchar.h></a>
wchar_t *fgetws(wchar_t * restrict s,
#include <a href="#7.19"><stdio.h></a>
#include <a href="#7.24"><wchar.h></a>
int fputws(const wchar_t * restrict s,
#include <a href="#7.19"><stdio.h></a>
#include <a href="#7.24"><wchar.h></a>
int fputws(const wchar_t * restrict s,
float wcstof(const wchar_t * restrict nptr,
wchar_t ** restrict endptr);
long double wcstold(const wchar_t * restrict nptr,
float wcstof(const wchar_t * restrict nptr,
wchar_t ** restrict endptr);
long double wcstold(const wchar_t * restrict nptr,
</ul>
The subject sequence is defined as the longest initial subsequence of the input wide
string, starting with the first non-white-space wide character, that is of the expected form.
</ul>
The subject sequence is defined as the longest initial subsequence of the input wide
string, starting with the first non-white-space wide character, that is of the expected form.
If the subject sequence is empty or does not have the expected form, no conversion is
performed; the value of nptr is stored in the object pointed to by endptr, provided
that endptr is not a null pointer.
If the subject sequence is empty or does not have the expected form, no conversion is
performed; the value of nptr is stored in the object pointed to by endptr, provided
that endptr is not a null pointer.
<p><!--para 8 -->
If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
the result is not exactly representable, the result should be one of the two numbers in the
<p><!--para 8 -->
If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
the result is not exactly representable, the result should be one of the two numbers in the
unsigned long long int wcstoull(
const wchar_t * restrict nptr,
wchar_t ** restrict endptr,
unsigned long long int wcstoull(
const wchar_t * restrict nptr,
wchar_t ** restrict endptr,
<h6>Description</h6>
<p><!--para 2 -->
The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
<h6>Description</h6>
<p><!--para 2 -->
The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
<pre>
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcscpy(wchar_t * restrict s1,
<pre>
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcscpy(wchar_t * restrict s1,
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcsncpy(wchar_t * restrict s1,
const wchar_t * restrict s2,
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcsncpy(wchar_t * restrict s1,
const wchar_t * restrict s2,
#include <a href="#7.24"><wchar.h></a>
wchar_t *wmemcpy(wchar_t * restrict s1,
const wchar_t * restrict s2,
#include <a href="#7.24"><wchar.h></a>
wchar_t *wmemcpy(wchar_t * restrict s1,
const wchar_t * restrict s2,
<pre>
#include <a href="#7.24"><wchar.h></a>
wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
<pre>
#include <a href="#7.24"><wchar.h></a>
wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
<pre>
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcscat(wchar_t * restrict s1,
<pre>
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcscat(wchar_t * restrict s1,
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcsncat(wchar_t * restrict s1,
const wchar_t * restrict s2,
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcsncat(wchar_t * restrict s1,
const wchar_t * restrict s2,
<pre>
#include <a href="#7.24"><wchar.h></a>
int wcsncmp(const wchar_t *s1, const wchar_t *s2,
<pre>
#include <a href="#7.24"><wchar.h></a>
int wcsncmp(const wchar_t *s1, const wchar_t *s2,
#include <a href="#7.24"><wchar.h></a>
size_t wcsxfrm(wchar_t * restrict s1,
const wchar_t * restrict s2,
#include <a href="#7.24"><wchar.h></a>
size_t wcsxfrm(wchar_t * restrict s1,
const wchar_t * restrict s2,
<pre>
#include <a href="#7.24"><wchar.h></a>
int wmemcmp(const wchar_t *s1, const wchar_t *s2,
<pre>
#include <a href="#7.24"><wchar.h></a>
int wmemcmp(const wchar_t *s1, const wchar_t *s2,
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcstok(wchar_t * restrict s1,
const wchar_t * restrict s2,
#include <a href="#7.24"><wchar.h></a>
wchar_t *wcstok(wchar_t * restrict s1,
const wchar_t * restrict s2,
t = wcstok(NULL, L",", &ptr1); // t points to the token L"??b"
t = wcstok(str2, L" \t", &ptr2); // t is a null pointer
t = wcstok(NULL, L"#,", &ptr1); // t points to the token L"c"
t = wcstok(NULL, L",", &ptr1); // t points to the token L"??b"
t = wcstok(str2, L" \t", &ptr2); // t is a null pointer
t = wcstok(NULL, L"#,", &ptr1); // t points to the token L"c"
<pre>
#include <a href="#7.24"><wchar.h></a>
wchar_t *wmemchr(const wchar_t *s, wchar_t c,
<pre>
#include <a href="#7.24"><wchar.h></a>
wchar_t *wmemchr(const wchar_t *s, wchar_t c,
size_t wcsftime(wchar_t * restrict s,
size_t maxsize,
const wchar_t * restrict format,
size_t wcsftime(wchar_t * restrict s,
size_t maxsize,
const wchar_t * restrict format,
#include <a href="#7.24"><wchar.h></a>
size_t mbrlen(const char * restrict s,
size_t n,
#include <a href="#7.24"><wchar.h></a>
size_t mbrlen(const char * restrict s,
size_t n,
- mbrtowc(NULL, s, n, ps != NULL ? ps : &internal)</pre>
+ mbrtowc(NULL, s, n, ps != NULL ? ps : &internal)
+</pre>
where internal is the mbstate_t object for the mbrlen function, except that the
expression designated by ps is evaluated only once.
<h6>Returns</h6>
where internal is the mbstate_t object for the mbrlen function, except that the
expression designated by ps is evaluated only once.
<h6>Returns</h6>
- mbrtowc(NULL, "", 1, ps)</pre>
+ mbrtowc(NULL, "", 1, ps)
+</pre>
In this case, the values of the parameters pwc and n are ignored.
<p><!--para 3 -->
If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
In this case, the values of the parameters pwc and n are ignored.
<p><!--para 3 -->
If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
#include <a href="#7.24"><wchar.h></a>
size_t wcrtomb(char * restrict s,
wchar_t wc,
#include <a href="#7.24"><wchar.h></a>
size_t wcrtomb(char * restrict s,
wchar_t wc,
where buf is an internal buffer.
<p><!--para 3 -->
If s is not a null pointer, the wcrtomb function determines the number of bytes needed
where buf is an internal buffer.
<p><!--para 3 -->
If s is not a null pointer, the wcrtomb function determines the number of bytes needed
size_t mbsrtowcs(wchar_t * restrict dst,
const char ** restrict src,
size_t len,
size_t mbsrtowcs(wchar_t * restrict dst,
const char ** restrict src,
size_t len,
size_t wcsrtombs(char * restrict dst,
const wchar_t ** restrict src,
size_t len,
size_t wcsrtombs(char * restrict dst,
const wchar_t ** restrict src,
size_t len,
iswctype(wc, wctype("punct")) // iswpunct(wc)
iswctype(wc, wctype("space")) // iswspace(wc)
iswctype(wc, wctype("upper")) // iswupper(wc)
iswctype(wc, wctype("punct")) // iswpunct(wc)
iswctype(wc, wctype("space")) // iswspace(wc)
iswctype(wc, wctype("upper")) // iswupper(wc)
mapping function (<a href="#7.25.3.1">7.25.3.1</a>) in the comment that follows the expression:
<pre>
towctrans(wc, wctrans("tolower")) // towlower(wc)
mapping function (<a href="#7.25.3.1">7.25.3.1</a>) in the comment that follows the expression:
<pre>
towctrans(wc, wctrans("tolower")) // towlower(wc)
and the same names suffixed with f or l may be added to the declarations in the
<a href="#7.3"><complex.h></a> header.
and the same names suffixed with f or l may be added to the declarations in the
<a href="#7.3"><complex.h></a> header.
<h4><a name="A.1.2" href="#A.1.2">A.1.2 Keywords</a></h4>
(<a href="#6.4.1">6.4.1</a>) keyword: one of
<h4><a name="A.1.2" href="#A.1.2">A.1.2 Keywords</a></h4>
(<a href="#6.4.1">6.4.1</a>) keyword: one of
<h4><a name="A.1.3" href="#A.1.3">A.1.3 Identifiers</a></h4>
(<a href="#6.4.2.1">6.4.2.1</a>) identifier:
<pre>
identifier-nondigit
identifier identifier-nondigit
<h4><a name="A.1.3" href="#A.1.3">A.1.3 Identifiers</a></h4>
(<a href="#6.4.2.1">6.4.2.1</a>) identifier:
<pre>
identifier-nondigit
identifier identifier-nondigit
(<a href="#6.4.2.1">6.4.2.1</a>) nondigit: one of
<pre>
_ a b c d e f g h i j k l m
n o p q r s t u v w x y z
A B C D E F G H I J K L M
(<a href="#6.4.2.1">6.4.2.1</a>) nondigit: one of
<pre>
_ a b c d e f g h i j k l m
n o p q r s t u v w x y z
A B C D E F G H I J K L M
<h4><a name="A.1.4" href="#A.1.4">A.1.4 Universal character names</a></h4>
(<a href="#6.4.3">6.4.3</a>) universal-character-name:
<pre>
\u hex-quad
<h4><a name="A.1.4" href="#A.1.4">A.1.4 Universal character names</a></h4>
(<a href="#6.4.3">6.4.3</a>) universal-character-name:
<pre>
\u hex-quad
(<a href="#6.4.4.1">6.4.4.1</a>) integer-constant:
<pre>
decimal-constant integer-suffixopt
octal-constant integer-suffixopt
(<a href="#6.4.4.1">6.4.4.1</a>) integer-constant:
<pre>
decimal-constant integer-suffixopt
octal-constant integer-suffixopt
(<a href="#6.4.4.1">6.4.4.1</a>) integer-suffix:
<pre>
unsigned-suffix long-suffixopt
unsigned-suffix long-long-suffix
long-suffix unsigned-suffixopt
(<a href="#6.4.4.1">6.4.4.1</a>) integer-suffix:
<pre>
unsigned-suffix long-suffixopt
unsigned-suffix long-long-suffix
long-suffix unsigned-suffixopt
(<a href="#6.4.4.2">6.4.4.2</a>) decimal-floating-constant:
<!--page 418 -->
<pre>
fractional-constant exponent-partopt floating-suffixopt
(<a href="#6.4.4.2">6.4.4.2</a>) decimal-floating-constant:
<!--page 418 -->
<pre>
fractional-constant exponent-partopt floating-suffixopt
(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-floating-constant:
<pre>
hexadecimal-prefix hexadecimal-fractional-constant
binary-exponent-part floating-suffixopt
hexadecimal-prefix hexadecimal-digit-sequence
(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-floating-constant:
<pre>
hexadecimal-prefix hexadecimal-fractional-constant
binary-exponent-part floating-suffixopt
hexadecimal-prefix hexadecimal-digit-sequence
(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-fractional-constant:
<pre>
hexadecimal-digit-sequenceopt .
hexadecimal-digit-sequence
(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-fractional-constant:
<pre>
hexadecimal-digit-sequenceopt .
hexadecimal-digit-sequence
(<a href="#6.4.4.4">6.4.4.4</a>) c-char:
<pre>
any member of the source character set except
the single-quote ', backslash \, or new-line character
(<a href="#6.4.4.4">6.4.4.4</a>) c-char:
<pre>
any member of the source character set except
the single-quote ', backslash \, or new-line character
<h4><a name="A.1.6" href="#A.1.6">A.1.6 String literals</a></h4>
(<a href="#6.4.5">6.4.5</a>) string-literal:
<pre>
" s-char-sequenceopt "
<h4><a name="A.1.6" href="#A.1.6">A.1.6 String literals</a></h4>
(<a href="#6.4.5">6.4.5</a>) string-literal:
<pre>
" s-char-sequenceopt "
(<a href="#6.4.5">6.4.5</a>) s-char:
<!--page 420 -->
<pre>
any member of the source character set except
the double-quote ", backslash \, or new-line character
(<a href="#6.4.5">6.4.5</a>) s-char:
<!--page 420 -->
<pre>
any member of the source character set except
the double-quote ", backslash \, or new-line character
<h4><a name="A.1.7" href="#A.1.7">A.1.7 Punctuators</a></h4>
(<a href="#6.4.6">6.4.6</a>) punctuator: one of
<h4><a name="A.1.7" href="#A.1.7">A.1.7 Punctuators</a></h4>
(<a href="#6.4.6">6.4.6</a>) punctuator: one of
<h4><a name="A.1.8" href="#A.1.8">A.1.8 Header names</a></h4>
(<a href="#6.4.7">6.4.7</a>) header-name:
<pre>
< h-char-sequence >
<h4><a name="A.1.8" href="#A.1.8">A.1.8 Header names</a></h4>
(<a href="#6.4.7">6.4.7</a>) header-name:
<pre>
< h-char-sequence >
<h4><a name="A.1.9" href="#A.1.9">A.1.9 Preprocessing numbers</a></h4>
(<a href="#6.4.8">6.4.8</a>) pp-number:
<h4><a name="A.1.9" href="#A.1.9">A.1.9 Preprocessing numbers</a></h4>
(<a href="#6.4.8">6.4.8</a>) pp-number:
(<a href="#6.5.5">6.5.5</a>) multiplicative-expression:
<!--page 422 -->
<pre>
cast-expression
multiplicative-expression * cast-expression
multiplicative-expression / cast-expression
(<a href="#6.5.5">6.5.5</a>) multiplicative-expression:
<!--page 422 -->
<pre>
cast-expression
multiplicative-expression * cast-expression
multiplicative-expression / cast-expression
(<a href="#6.5.6">6.5.6</a>) additive-expression:
<pre>
multiplicative-expression
additive-expression + multiplicative-expression
(<a href="#6.5.6">6.5.6</a>) additive-expression:
<pre>
multiplicative-expression
additive-expression + multiplicative-expression
(<a href="#6.5.8">6.5.8</a>) relational-expression:
<pre>
shift-expression
relational-expression < shift-expression
relational-expression > shift-expression
relational-expression <= shift-expression
(<a href="#6.5.8">6.5.8</a>) relational-expression:
<pre>
shift-expression
relational-expression < shift-expression
relational-expression > shift-expression
relational-expression <= shift-expression
(<a href="#6.7">6.7</a>) declaration-specifiers:
<pre>
storage-class-specifier declaration-specifiersopt
type-specifier declaration-specifiersopt
type-qualifier declaration-specifiersopt
(<a href="#6.7">6.7</a>) declaration-specifiers:
<pre>
storage-class-specifier declaration-specifiersopt
type-specifier declaration-specifiersopt
type-qualifier declaration-specifiersopt
(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union-specifier:
<pre>
struct-or-union identifieropt { struct-declaration-list }
(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union-specifier:
<pre>
struct-or-union identifieropt { struct-declaration-list }
(<a href="#6.7.2.1">6.7.2.1</a>) specifier-qualifier-list:
<pre>
type-specifier specifier-qualifier-listopt
(<a href="#6.7.2.1">6.7.2.1</a>) specifier-qualifier-list:
<pre>
type-specifier specifier-qualifier-listopt
(<a href="#6.7.2.2">6.7.2.2</a>) enum-specifier:
<pre>
enum identifieropt { enumerator-list }
enum identifieropt { enumerator-list , }
(<a href="#6.7.2.2">6.7.2.2</a>) enum-specifier:
<pre>
enum identifieropt { enumerator-list }
enum identifieropt { enumerator-list , }
direct-declarator [ type-qualifier-list static assignment-expression ]
direct-declarator [ type-qualifier-listopt * ]
direct-declarator ( parameter-type-list )
direct-declarator [ type-qualifier-list static assignment-expression ]
direct-declarator [ type-qualifier-listopt * ]
direct-declarator ( parameter-type-list )
(<a href="#6.8.4">6.8.4</a>) selection-statement:
<!--page 428 -->
<pre>
if ( expression ) statement
if ( expression ) statement else statement
(<a href="#6.8.4">6.8.4</a>) selection-statement:
<!--page 428 -->
<pre>
if ( expression ) statement
if ( expression ) statement else statement
(<a href="#6.8.5">6.8.5</a>) iteration-statement:
<pre>
while ( expression ) statement
do statement while ( expression ) ;
for ( expressionopt ; expressionopt ; expressionopt ) statement
(<a href="#6.8.5">6.8.5</a>) iteration-statement:
<pre>
while ( expression ) statement
do statement while ( expression ) ;
for ( expressionopt ; expressionopt ; expressionopt ) statement
<h4><a name="A.2.4" href="#A.2.4">A.2.4 External definitions</a></h4>
(<a href="#6.9">6.9</a>) translation-unit:
<pre>
external-declaration
<h4><a name="A.2.4" href="#A.2.4">A.2.4 External definitions</a></h4>
(<a href="#6.9">6.9</a>) translation-unit:
<pre>
external-declaration
<h3><a name="A.3" href="#A.3">A.3 Preprocessing directives</a></h3>
(<a href="#6.10">6.10</a>) preprocessing-file:
<pre>
<h3><a name="A.3" href="#A.3">A.3 Preprocessing directives</a></h3>
(<a href="#6.10">6.10</a>) preprocessing-file:
<pre>
(<a href="#6.10">6.10</a>) if-group:
<pre>
# if constant-expression new-line groupopt
# ifdef identifier new-line groupopt
(<a href="#6.10">6.10</a>) if-group:
<pre>
# if constant-expression new-line groupopt
# ifdef identifier new-line groupopt
# line pp-tokens new-line
# error pp-tokensopt new-line
# pragma pp-tokensopt new-line
# line pp-tokens new-line
# error pp-tokensopt new-line
# pragma pp-tokensopt new-line
long double complex cprojl(long double complex z);
double creal(double complex z);
float crealf(float complex z);
long double complex cprojl(long double complex z);
double creal(double complex z);
float crealf(float complex z);
int fegetenv(fenv_t *envp);
int feholdexcept(fenv_t *envp);
int fesetenv(const fenv_t *envp);
int fegetenv(fenv_t *envp);
int feholdexcept(fenv_t *envp);
int fesetenv(const fenv_t *envp);
intmax_t wcstoimax(const wchar_t * restrict nptr,
wchar_t ** restrict endptr, int base);
uintmax_t wcstoumax(const wchar_t * restrict nptr,
intmax_t wcstoimax(const wchar_t * restrict nptr,
wchar_t ** restrict endptr, int base);
uintmax_t wcstoumax(const wchar_t * restrict nptr,
SCHAR_MIN MB_LEN_MAX INT_MAX LLONG_MIN
SCHAR_MAX SHRT_MIN UINT_MAX LLONG_MAX
UCHAR_MAX SHRT_MAX LONG_MIN ULLONG_MAX
SCHAR_MIN MB_LEN_MAX INT_MAX LLONG_MIN
SCHAR_MAX SHRT_MIN UINT_MAX LLONG_MAX
UCHAR_MAX SHRT_MAX LONG_MIN ULLONG_MAX
<h3><a name="B.10" href="#B.10">B.10 Localization <locale.h></a></h3>
<pre>
struct lconv LC_ALL LC_CTYPE LC_NUMERIC
NULL LC_COLLATE LC_MONETARY LC_TIME
char *setlocale(int category, const char *locale);
<h3><a name="B.10" href="#B.10">B.10 Localization <locale.h></a></h3>
<pre>
struct lconv LC_ALL LC_CTYPE LC_NUMERIC
NULL LC_COLLATE LC_MONETARY LC_TIME
char *setlocale(int category, const char *locale);
int isless(real-floating x, real-floating y);
int islessequal(real-floating x, real-floating y);
int islessgreater(real-floating x, real-floating y);
int isless(real-floating x, real-floating y);
int islessequal(real-floating x, real-floating y);
int islessgreater(real-floating x, real-floating y);
type va_arg(va_list ap, type);
void va_copy(va_list dest, va_list src);
void va_end(va_list ap);
type va_arg(va_list ap, type);
void va_copy(va_list dest, va_list src);
void va_end(va_list ap);
<h3><a name="B.16" href="#B.16">B.16 Common definitions <stddef.h></a></h3>
<pre>
ptrdiff_t size_t wchar_t NULL
<h3><a name="B.16" href="#B.16">B.16 Common definitions <stddef.h></a></h3>
<pre>
ptrdiff_t size_t wchar_t NULL
uintmax_t INTMAX_MIN UINTN_C(value)
INTN_MIN INTMAX_MAX INTMAX_C(value)
INTN_MAX UINTMAX_MAX UINTMAX_C(value)
uintmax_t INTMAX_MIN UINTN_C(value)
INTN_MIN INTMAX_MAX INTMAX_C(value)
INTN_MAX UINTMAX_MAX UINTMAX_C(value)
size_t mbstowcs(wchar_t * restrict pwcs,
const char * restrict s, size_t n);
size_t wcstombs(char * restrict s,
size_t mbstowcs(wchar_t * restrict pwcs,
const char * restrict s, size_t n);
size_t wcstombs(char * restrict s,
const char * restrict s2);
void *memset(void *s, int c, size_t n);
char *strerror(int errnum);
const char * restrict s2);
void *memset(void *s, int c, size_t n);
char *strerror(int errnum);
size_t strftime(char * restrict s,
size_t maxsize,
const char * restrict format,
size_t strftime(char * restrict s,
size_t maxsize,
const char * restrict format,
mbstate_t * restrict ps);
size_t wcsrtombs(char * restrict dst,
const wchar_t ** restrict src, size_t len,
mbstate_t * restrict ps);
size_t wcsrtombs(char * restrict dst,
const wchar_t ** restrict src, size_t len,
wint_t towlower(wint_t wc);
wint_t towupper(wint_t wc);
wint_t towctrans(wint_t wc, wctrans_t desc);
wint_t towlower(wint_t wc);
wint_t towupper(wint_t wc);
wint_t towctrans(wint_t wc, wctrans_t desc);
The following are the sequence points described in <a href="#5.1.2.3">5.1.2.3</a>:
<ul>
<li> The call to a function, after the arguments have been evaluated (<a href="#6.5.2.2">6.5.2.2</a>).
The following are the sequence points described in <a href="#5.1.2.3">5.1.2.3</a>:
<ul>
<li> The call to a function, after the arguments have been evaluated (<a href="#6.5.2.2">6.5.2.2</a>).
sets.
Latin: 00AA, 00BA, 00C0-00D6, 00D8-00F6, 00F8-01F5, 01FA-0217,
<pre>
sets.
Latin: 00AA, 00BA, 00C0-00D6, 00D8-00F6, 00F8-01F5, 01FA-0217,
<pre>
- 0250-02A8, 1E00-1E9B, 1EA0-1EF9, 207F</pre>
+ 0250-02A8, 1E00-1E9B, 1EA0-1EF9, 207F
+</pre>
Greek: 0386, 0388-038A, 038C, 038E-03A1, 03A3-03CE, 03D0-03D6,
<pre>
03DA, 03DC, 03DE, 03E0, 03E2-03F3, 1F00-1F15, 1F18-1F1D,
1F20-1F45, 1F48-1F4D, 1F50-1F57, 1F59, 1F5B, 1F5D,
1F5F-1F7D, 1F80-1FB4, 1FB6-1FBC, 1FC2-1FC4, 1FC6-1FCC,
Greek: 0386, 0388-038A, 038C, 038E-03A1, 03A3-03CE, 03D0-03D6,
<pre>
03DA, 03DC, 03DE, 03E0, 03E2-03F3, 1F00-1F15, 1F18-1F1D,
1F20-1F45, 1F48-1F4D, 1F50-1F57, 1F59, 1F5B, 1F5D,
1F5F-1F7D, 1F80-1FB4, 1FB6-1FBC, 1FC2-1FC4, 1FC6-1FCC,
- 1FD0-1FD3, 1FD6-1FDB, 1FE0-1FEC, 1FF2-1FF4, 1FF6-1FFC</pre>
+ 1FD0-1FD3, 1FD6-1FDB, 1FE0-1FEC, 1FF2-1FF4, 1FF6-1FFC
+</pre>
Cyrillic: 0401-040C, 040E-044F, 0451-045C, 045E-0481, 0490-04C4,
<pre>
Cyrillic: 0401-040C, 040E-044F, 0451-045C, 045E-0481, 0490-04C4,
<pre>
- 04C7-04C8, 04CB-04CC, 04D0-04EB, 04EE-04F5, 04F8-04F9</pre>
+ 04C7-04C8, 04CB-04CC, 04D0-04EB, 04EE-04F5, 04F8-04F9
+</pre>
Armenian: 0531-0556, 0561-0587
Hebrew: 05B0-05B9, 05BB-05BD, 05BF, 05C1-05C2, 05D0-05EA,
<pre>
Armenian: 0531-0556, 0561-0587
Hebrew: 05B0-05B9, 05BB-05BD, 05BF, 05C1-05C2, 05D0-05EA,
<pre>
Arabic: 0621-063A, 0640-0652, 0670-06B7, 06BA-06BE, 06C0-06CE,
<pre>
Arabic: 0621-063A, 0640-0652, 0670-06B7, 06BA-06BE, 06C0-06CE,
<pre>
Devanagari: 0901-0903, 0905-0939, 093E-094D, 0950-0952, 0958-0963
Bengali: 0981-0983, 0985-098C, 098F-0990, 0993-09A8, 09AA-09B0,
<pre>
09B2, 09B6-09B9, 09BE-09C4, 09C7-09C8, 09CB-09CD,
Devanagari: 0901-0903, 0905-0939, 093E-094D, 0950-0952, 0958-0963
Bengali: 0981-0983, 0985-098C, 098F-0990, 0993-09A8, 09AA-09B0,
<pre>
09B2, 09B6-09B9, 09BE-09C4, 09C7-09C8, 09CB-09CD,
Gurmukhi: 0A02, 0A05-0A0A, 0A0F-0A10, 0A13-0A28, 0A2A-0A30,
<pre>
0A32-0A33, 0A35-0A36, 0A38-0A39, 0A3E-0A42, 0A47-0A48,
Gurmukhi: 0A02, 0A05-0A0A, 0A0F-0A10, 0A13-0A28, 0A2A-0A30,
<pre>
0A32-0A33, 0A35-0A36, 0A38-0A39, 0A3E-0A42, 0A47-0A48,
- 0A4B-0A4D, 0A59-0A5C, 0A5E, 0A74</pre>
+ 0A4B-0A4D, 0A59-0A5C, 0A5E, 0A74
+</pre>
Gujarati: 0A81-0A83, 0A85-0A8B, 0A8D, 0A8F-0A91, 0A93-0AA8,
<pre>
0AAA-0AB0, 0AB2-0AB3, 0AB5-0AB9, 0ABD-0AC5,
Gujarati: 0A81-0A83, 0A85-0A8B, 0A8D, 0A8F-0A91, 0A93-0AA8,
<pre>
0AAA-0AB0, 0AB2-0AB3, 0AB5-0AB9, 0ABD-0AC5,
- 0AC7-0AC9, 0ACB-0ACD, 0AD0, 0AE0</pre>
+ 0AC7-0AC9, 0ACB-0ACD, 0AD0, 0AE0
+</pre>
Oriya: 0B01-0B03, 0B05-0B0C, 0B0F-0B10, 0B13-0B28, 0B2A-0B30,
<!--page 453 -->
<pre>
0B32-0B33, 0B36-0B39, 0B3E-0B43, 0B47-0B48, 0B4B-0B4D,
Oriya: 0B01-0B03, 0B05-0B0C, 0B0F-0B10, 0B13-0B28, 0B2A-0B30,
<!--page 453 -->
<pre>
0B32-0B33, 0B36-0B39, 0B3E-0B43, 0B47-0B48, 0B4B-0B4D,
Tamil: 0B82-0B83, 0B85-0B8A, 0B8E-0B90, 0B92-0B95, 0B99-0B9A,
<pre>
0B9C, 0B9E-0B9F, 0BA3-0BA4, 0BA8-0BAA, 0BAE-0BB5,
Tamil: 0B82-0B83, 0B85-0B8A, 0B8E-0B90, 0B92-0B95, 0B99-0B9A,
<pre>
0B9C, 0B9E-0B9F, 0BA3-0BA4, 0BA8-0BAA, 0BAE-0BB5,
- 0BB7-0BB9, 0BBE-0BC2, 0BC6-0BC8, 0BCA-0BCD</pre>
+ 0BB7-0BB9, 0BBE-0BC2, 0BC6-0BC8, 0BCA-0BCD
+</pre>
Telugu: 0C01-0C03, 0C05-0C0C, 0C0E-0C10, 0C12-0C28, 0C2A-0C33,
<pre>
Telugu: 0C01-0C03, 0C05-0C0C, 0C0E-0C10, 0C12-0C28, 0C2A-0C33,
<pre>
- 0C35-0C39, 0C3E-0C44, 0C46-0C48, 0C4A-0C4D, 0C60-0C61</pre>
+ 0C35-0C39, 0C3E-0C44, 0C46-0C48, 0C4A-0C4D, 0C60-0C61
+</pre>
Kannada: 0C82-0C83, 0C85-0C8C, 0C8E-0C90, 0C92-0CA8, 0CAA-0CB3,
<pre>
0CB5-0CB9, 0CBE-0CC4, 0CC6-0CC8, 0CCA-0CCD, 0CDE,
Kannada: 0C82-0C83, 0C85-0C8C, 0C8E-0C90, 0C92-0CA8, 0CAA-0CB3,
<pre>
0CB5-0CB9, 0CBE-0CC4, 0CC6-0CC8, 0CCA-0CCD, 0CDE,
Malayalam: 0D02-0D03, 0D05-0D0C, 0D0E-0D10, 0D12-0D28, 0D2A-0D39,
<pre>
Malayalam: 0D02-0D03, 0D05-0D0C, 0D0E-0D10, 0D12-0D28, 0D2A-0D39,
<pre>
- 0D3E-0D43, 0D46-0D48, 0D4A-0D4D, 0D60-0D61</pre>
+ 0D3E-0D43, 0D46-0D48, 0D4A-0D4D, 0D60-0D61
+</pre>
Thai: 0E01-0E3A, 0E40-0E5B
Lao: 0E81-0E82, 0E84, 0E87-0E88, 0E8A, 0E8D, 0E94-0E97,
<pre>
0E99-0E9F, 0EA1-0EA3, 0EA5, 0EA7, 0EAA-0EAB,
0EAD-0EAE, 0EB0-0EB9, 0EBB-0EBD, 0EC0-0EC4, 0EC6,
Thai: 0E01-0E3A, 0E40-0E5B
Lao: 0E81-0E82, 0E84, 0E87-0E88, 0E8A, 0E8D, 0E94-0E97,
<pre>
0E99-0E9F, 0EA1-0EA3, 0EA5, 0EA7, 0EAA-0EAB,
0EAD-0EAE, 0EB0-0EB9, 0EBB-0EBD, 0EC0-0EC4, 0EC6,
Tibetan: 0F00, 0F18-0F19, 0F35, 0F37, 0F39, 0F3E-0F47, 0F49-0F69,
<pre>
0F71-0F84, 0F86-0F8B, 0F90-0F95, 0F97, 0F99-0FAD,
Tibetan: 0F00, 0F18-0F19, 0F35, 0F37, 0F39, 0F3E-0F47, 0F49-0F69,
<pre>
0F71-0F84, 0F86-0F8B, 0F90-0F95, 0F97, 0F99-0FAD,
Georgian: 10A0-10C5, 10D0-10F6
Hiragana: 3041-3093, 309B-309C
Katakana: 30A1-30F6, 30FB-30FC
Georgian: 10A0-10C5, 10D0-10F6
Hiragana: 3041-3093, 309B-309C
Katakana: 30A1-30F6, 30FB-30FC
Digits: 0660-0669, 06F0-06F9, 0966-096F, 09E6-09EF, 0A66-0A6F,
<pre>
0AE6-0AEF, 0B66-0B6F, 0BE7-0BEF, 0C66-0C6F, 0CE6-0CEF,
Digits: 0660-0669, 06F0-06F9, 0966-096F, 09E6-09EF, 0A66-0A6F,
<pre>
0AE6-0AEF, 0B66-0B6F, 0BE7-0BEF, 0C66-0C6F, 0CE6-0CEF,
- 0D66-0D6F, 0E50-0E59, 0ED0-0ED9, 0F20-0F33</pre>
+ 0D66-0D6F, 0E50-0E59, 0ED0-0ED9, 0F20-0F33
+</pre>
Special characters: 00B5, 00B7, 02B0-02B8, 02BB, 02BD-02C1, 02D0-02D1,
<!--page 454 -->
<pre>
02E0-02E4, 037A, 0559, 093D, 0B3D, 1FBE, 203F-2040, 2102,
2107, 210A-2113, 2115, 2118-211D, 2124, 2126, 2128, 212A-2131,
Special characters: 00B5, 00B7, 02B0-02B8, 02BB, 02BD-02C1, 02D0-02D1,
<!--page 454 -->
<pre>
02E0-02E4, 037A, 0559, 093D, 0B3D, 1FBE, 203F-2040, 2102,
2107, 210A-2113, 2115, 2118-211D, 2124, 2126, 2128, 212A-2131,
- 2133-2138, 2160-2182, 3005-3007, 3021-3029</pre>
+ 2133-2138, 2160-2182, 3005-3007, 3021-3029
+</pre>
The contents of the header <a href="#7.10"><limits.h></a> are given below, in alphabetical order. The
minimum magnitudes shown shall be replaced by implementation-defined magnitudes
with the same sign. The values shall all be constant expressions suitable for use in #if
The contents of the header <a href="#7.10"><limits.h></a> are given below, in alphabetical order. The
minimum magnitudes shown shall be replaced by implementation-defined magnitudes
with the same sign. The values shall all be constant expressions suitable for use in #if
The contents of the header <a href="#7.7"><float.h></a> are given below. All integer values, except
FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
directives; all floating values shall be constant expressions. The components are
The contents of the header <a href="#7.7"><float.h></a> are given below. All integer values, except
FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
directives; all floating values shall be constant expressions. The components are
The values given in the following list shall be replaced by implementation-defined
constant expressions that are greater or equal in magnitude (absolute value) to those
shown, with the same sign:
The values given in the following list shall be replaced by implementation-defined
constant expressions that are greater or equal in magnitude (absolute value) to those
shown, with the same sign:
The values given in the following list shall be replaced by implementation-defined
constant expressions with values that are greater than or equal to those shown:
<p><!--para 6 -->
<pre>
#define DBL_MAX 1E+37
#define FLT_MAX 1E+37
The values given in the following list shall be replaced by implementation-defined
constant expressions with values that are greater than or equal to those shown:
<p><!--para 6 -->
<pre>
#define DBL_MAX 1E+37
#define FLT_MAX 1E+37
The values given in the following list shall be replaced by implementation-defined
constant expressions with (positive) values that are less than or equal to those shown:
<!--page 456 -->
The values given in the following list shall be replaced by implementation-defined
constant expressions with (positive) values that are less than or equal to those shown:
<!--page 456 -->
</ul>
Any non-IEC 60559 extended format used for the long double type shall have more
precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note308"><b>308)</b></a></sup>
</ul>
Any non-IEC 60559 extended format used for the long double type shall have more
precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note308"><b>308)</b></a></sup>
A contracted expression treats infinities, NaNs, signed zeros, subnormals, and the
rounding directions in a manner consistent with the basic arithmetic operations covered
by IEC 60559.
A contracted expression treats infinities, NaNs, signed zeros, subnormals, and the
rounding directions in a manner consistent with the basic arithmetic operations covered
by IEC 60559.
<p><!--para 2 -->
A contracted expression should raise floating-point exceptions in a manner generally
consistent with the basic arithmetic operations. A contracted expression should deliver
<p><!--para 2 -->
A contracted expression should raise floating-point exceptions in a manner generally
consistent with the basic arithmetic operations. A contracted expression should deliver
<li> The rounding precision mode (if supported) is set so that results are not shortened.
<li> Trapping or stopping (if supported) is disabled on all floating-point exceptions.
</ul>
<li> The rounding precision mode (if supported) is set so that results are not shortened.
<li> Trapping or stopping (if supported) is disabled on all floating-point exceptions.
</ul>
For the static initialization, the division is done at translation time, raising no (execution-time) floating-
point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
For the static initialization, the division is done at translation time, raising no (execution-time) floating-
point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
done at translation time. The automatic initialization of u and w require an execution-time conversion to
float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
done at translation time. The automatic initialization of u and w require an execution-time conversion to
float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
body might not execute (maybe 0 >= n), x + 1 cannot be moved out of the loop. (Of
course these optimizations are valid if the implementation can rule out the nettlesome
x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
body might not execute (maybe 0 >= n), x + 1 cannot be moved out of the loop. (Of
course these optimizations are valid if the implementation can rule out the nettlesome
constants generally do not yield numerically equivalent
expressions, if the constants are exact then such
transformations can be made on IEC 60559 machines
constants generally do not yield numerically equivalent
expressions, if the constants are exact then such
transformations can be made on IEC 60559 machines
x - y <-> -(y - x) The expressions x - y and -(y - x) are not
<pre>
equivalent because 1 - 1 is +0 but -(1 - 1) is -0 (in the
x - y <-> -(y - x) The expressions x - y and -(y - x) are not
<pre>
equivalent because 1 - 1 is +0 but -(1 - 1) is -0 (in the
x + 0->x The expressions x + 0 and x are not equivalent if x is
<pre>
-0, because (-0) + (+0) yields +0 (in the default
x + 0->x The expressions x + 0 and x are not equivalent if x is
<pre>
-0, because (-0) + (+0) yields +0 (in the default
x - 0->x (+0) - (+0) yields -0 when rounding is downward
<pre>
(toward -(inf)), but +0 otherwise, and (-0) - (+0) always
yields -0; so, if the state of the FENV_ACCESS pragma
is ''off'', promising default rounding, then the
x - 0->x (+0) - (+0) yields -0 when rounding is downward
<pre>
(toward -(inf)), but +0 otherwise, and (-0) - (+0) always
yields -0; so, if the state of the FENV_ACCESS pragma
is ''off'', promising default rounding, then the
-x <-> 0 - x The expressions -x and 0 - x are not equivalent if x
<pre>
is +0, because -(+0) yields -0, but 0 - (+0) yields +0
-x <-> 0 - x The expressions -x and 0 - x are not equivalent if x
<pre>
is +0, because -(+0) yields -0, but 0 - (+0) yields +0
which would be desirable if extra code were required to
cause the ''invalid'' floating-point exception for
unordered cases, could be performed provided the state
which would be desirable if extra code were required to
cause the ''invalid'' floating-point exception for
unordered cases, could be performed provided the state
The sense of relational operators shall be maintained. This includes handling unordered
cases as expressed by the source code.
<p><!--para 2 -->
The sense of relational operators shall be maintained. This includes handling unordered
cases as expressed by the source code.
<p><!--para 2 -->
For families of functions, the specifications apply to all of the functions even though only
the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
occurs in both an argument and the result, the result has the same sign as the argument.
For families of functions, the specifications apply to all of the functions even though only
the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
occurs in both an argument and the result, the result has the same sign as the argument.
<p><!--para 13 -->
If a function with one or more NaN arguments returns a NaN result, the result should be
the same as one of the NaN arguments (after possible type conversion), except perhaps
<p><!--para 13 -->
If a function with one or more NaN arguments returns a NaN result, the result should be
the same as one of the NaN arguments (after possible type conversion), except perhaps
{
*exp = (value == 0) ? 0 : (int)(1 + logb(value));
return scalbn(value, -(*exp));
{
*exp = (value == 0) ? 0 : (int)(1 + logb(value));
return scalbn(value, -(*exp));
The round functions may, but are not required to, raise the ''inexact'' floating-point
exception for non-integer numeric arguments, as this implementation does.
The round functions may, but are not required to, raise the ''inexact'' floating-point
exception for non-integer numeric arguments, as this implementation does.
result = remainder(fabs(x), (y = fabs(y)));
if (signbit(result)) result += y;
return copysign(result, x);
result = remainder(fabs(x), (y = fabs(y)));
if (signbit(result)) result += y;
return copysign(result, x);
The body of the fmax function might be<sup><a href="#note323"><b>323)</b></a></sup>
<pre>
{ return (isgreaterequal(x, y) ||
The body of the fmax function might be<sup><a href="#note323"><b>323)</b></a></sup>
<pre>
{ return (isgreaterequal(x, y) ||
<h6>footnotes</h6>
<p><small><a name="note323" href="#note323">323)</a> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
<h6>footnotes</h6>
<p><small><a name="note323" href="#note323">323)</a> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
If the operands are not both complex, then the result and floating-point exception
behavior of the * operator is defined by the usual mathematical formula:
<pre>
If the operands are not both complex, then the result and floating-point exception
behavior of the * operator is defined by the usual mathematical formula:
<pre>
If the second operand is not complex, then the result and floating-point exception
behavior of the / operator is defined by the usual mathematical formula:
<pre>
If the second operand is not complex, then the result and floating-point exception
behavior of the / operator is defined by the usual mathematical formula:
<pre>
The * and / operators satisfy the following infinity properties for all real, imaginary, and
complex operands:<sup><a href="#note325"><b>325)</b></a></sup>
<ul>
The * and / operators satisfy the following infinity properties for all real, imaginary, and
complex operands:<sup><a href="#note325"><b>325)</b></a></sup>
<ul>
This implementation achieves the required treatment of infinities at the cost of only one isnan test in
ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
This implementation achieves the required treatment of infinities at the cost of only one isnan test in
ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
for multiplication. In the spirit of the multiplication example above, this code does not defend against
overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
for multiplication. In the spirit of the multiplication example above, this code does not defend against
overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
In all cases the result and floating-point exception behavior of a + or - operator is defined
by the usual mathematical formula:
<pre>
In all cases the result and floating-point exception behavior of a + or - operator is defined
by the usual mathematical formula:
<pre>
are defined, respectively, as _Imaginary and a constant expression of type const
float _Imaginary with the value of the imaginary unit. The macro
<pre>
are defined, respectively, as _Imaginary and a constant expression of type const
float _Imaginary with the value of the imaginary unit. The macro
<pre>
is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
imaginary.
is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
imaginary.
Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
a formula in terms of other complex functions (whose special cases are specified below):
<p><!--para 8 -->
Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
a formula in terms of other complex functions (whose special cases are specified below):
<p><!--para 8 -->
For the other functions, the following subclauses specify behavior for special cases,
including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
families of functions, the specifications apply to all of the functions even though only the
For the other functions, the following subclauses specify behavior for special cases,
including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
families of functions, the specifications apply to all of the functions even though only the
The parameters for the integer data types can be accessed by the following:
maxint INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
<pre>
The parameters for the integer data types can be accessed by the following:
maxint INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
<pre>
minint INT_MIN, LONG_MIN, LLONG_MIN
<p><!--para 3 -->
The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
minint INT_MIN, LONG_MIN, LLONG_MIN
<p><!--para 3 -->
The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
exponentF 1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
scaleF scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
<pre>
exponentF 1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
scaleF scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
<pre>
- scalblnf(x, li), scalbln(x, li), scalblnl(x, li)</pre>
+ scalblnf(x, li), scalbln(x, li), scalblnl(x, li)
+</pre>
intpartF modff(x, &y), modf(x, &y), modfl(x, &y)
fractpartF modff(x, &y), modf(x, &y), modfl(x, &y)
eqF x == y
intpartF modff(x, &y), modf(x, &y), modfl(x, &y)
fractpartF modff(x, &y), modf(x, &y), modfl(x, &y)
eqF x == y
cvtI' -> I (int)i, (long int)i, (long long int)i,
<pre>
(unsigned int)i, (unsigned long int)i,
cvtI' -> I (int)i, (long int)i, (long long int)i,
<pre>
(unsigned int)i, (unsigned long int)i,
cvtF -> I (int)x, (long int)x, (long long int)x,
<pre>
(unsigned int)x, (unsigned long int)x,
cvtF -> I (int)x, (long int)x, (long long int)x,
<pre>
(unsigned int)x, (unsigned long int)x,
cvtI -> F (float)i, (double)i, (long double)i
cvtF' -> F (float)x, (double)x, (long double)x
<p><!--para 2 -->
cvtI -> F (float)i, (double)i, (long double)i
cvtF' -> F (float)x, (double)x, (long double)x
<p><!--para 2 -->
An implementation may generate warnings in many situations, none of which are
specified as part of this International Standard. The following are a few of the more
common situations.
An implementation may generate warnings in many situations, none of which are
specified as part of this International Standard. The following are a few of the more
common situations.
The asm keyword may be used to insert assembly language directly into the translator
output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
<pre>
The asm keyword may be used to insert assembly language directly into the translator
output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
<pre>