6.5 Expressions

Previous Table of Contents "New C Standard" commentary

940 An expression is a sequence of operators and operands that specifies computation of a value, or that designates an object or a function, or that generates side effects, or that performs a combination thereof.

941 Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression. ^DR287)

942 Furthermore, the prior value shall be read only to determine the value to be stored.⁷¹⁾

943 The grouping of operators and operands is indicated by the syntax.⁷²⁾

944 Except as specified later (for the function-call (), &&, ||, ?:, and comma operators), the order of evaluation of subexpressions and the order in which side effects take place are both unspecified.

945 Some operators (the unary operator ~, and the binary operators <<, >>, &, ^, and |, collectively described as bitwise operators) are required to have operands that have integer type.

946 These operators yield values that depend on the internal representations of integers, and have implementation-defined and undefined aspects for signed types.

947 If an exceptional condition occurs during the evaluation of an expression (that is, if the result is not mathematically defined or not in the range of representable values for its type), the behavior is undefined.

948 The effective type of an object for an access to its stored value is the declared type of the object, if any.⁷³⁾

949 If a value is stored into an object having no declared type through an lvalue having a type that is not a character type, then the type of the lvalue becomes the effective type of the object for that access and for subsequent accesses that do not modify the stored value.

950 71) This paragraph renders undefined statement expressions such as


        i = ++i + 1;
        a[i++] = i;

while allowing


        i = i + 1;
        a[i] = i;

951 72) The syntax specifies the precedence of operators in the evaluation of an expression, which is the same as the order of the major subclauses of this subclause, highest precedence first.

952 Thus, for example, the expressions allowed as the operands of the binary + operator (6.5.6) are those expressions defined in 6.5.1 through 6.5.6.

953 The exceptions are cast expressions (6.5.4) as operands of unary operators (6.5.3), and an operand contained between any of the following pairs of operators: grouping parentheses () (6.5.1), subscripting brackets [] (6.5.2.1), function-call parentheses () (6.5.2.2), and the conditional operator ?: (6.5.15).

954 Within each major subclause, the operators have the same precedence.

955 Left- or right-associativity is indicated in each subclause by the syntax for the expressions discussed therein.

956 73) Allocated objects have no declared type.

957 DR287) A floating-point status flag is not an object and can be set more than once within an expression.

958 If a value is copied into an object having no declared type using memcpy or memmove, or is copied as an array of character type, then the effective type of the modified object for that access and for subsequent accesses that do not modify the value is the effective type of the object from which the value is copied, if it has one.

959 For all other accesses to an object having no declared type, the effective type of the object is simply the type of the lvalue used for the access.

960 An object shall have its stored value accessed only by an lvalue expression that has one of the following types:⁷⁴⁾

961 — a type compatible with the effective type of the object,

962 — a qualified version of a type compatible with the effective type of the object,

963 — a type that is the signed or unsigned type corresponding to the effective type of the object,

964 — a type that is the signed or unsigned type corresponding to a qualified version of the effective type of the object,

965 — an aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or

966 — a character type.

967 A floating expression may be contracted, that is, evaluated as though it were an atomic operation, thereby omitting rounding errors implied by the source code and the expression evaluation method.⁷⁵⁾

968 The FP_CONTRACT pragma in <math.h> provides a way to disallow contracted expressions.

969 Otherwise, whether and how expressions are contracted is implementation-defined.⁷⁶⁾

970 Forward references: the FP_CONTRACT pragma (7.12.2), copying functions (7.21.2).

971 74) The intent of this list is to specify those circumstances in which an object may or may not be aliased.

972 75) A contracted expression might also omit the raising of floating-point exceptions.

973 76) This license is specifically intended to allow implementations to exploit fast machine instructions that combine multiple C operators.

974 As contractions potentially undermine predictability, and can even decrease accuracy for containing expressions, their use needs to be well-defined and clearly documented.