Variable names, function names, message expressions, array names, constants, function calls, array references, and structure and union references are all considered expressions. Applying a unary operator (where appropriate) to one of these expressions is also an expression, as is combining two or more of these expressions with a binary or ternary operator. Finally, an expression enclosed within parentheses is also an expression.

An expression of any type other than void that identifies a data object is called an lvalue. If it can be assigned a value, it is known as a modifiable lvalue.

Modifiable lvalue expressions are required in certain places. The expression on the left side of an assignment operator must be a modifiable lvalue.The unary address operator can be applied only to a modifiable lvalue or a function name. Finally, the increment and decrement operators can be applied only to modifiable lvalues.

Summary of Objective-C Operators

Table B.4 summarizes the various operators in the Objective-C language.These operators are listed in order of decreasing precedence, and operators grouped together have the same precedence.

As an example of how to use Table B.4, consider the following expression:

b | c & d * e

The multiplication operator has higher precedence than both the bitwise OR and bitwise AND operators because it appears above both of these in Table B.4. Similarly, the bitwise AND operator has higher precedence than the bitwise OR operator because the former appears above the latter in the table.Therefore, this expression would be evaluated as

b | ( c & ( d * e ) )

Now, consider the following expression:

b % c * d

Table B.4 Summary of Objective-C Operators

Because the modulus and multiplication operators appear in the same grouping in Table B.4, they have the same precedence.The associativity listed for these operators is left to right, indicating that the expression would be evaluated as follows:

( b % c ) * d

As another example, the expression

++a->b

would be evaluated as

++(a->b)

because the -> operator has higher precedence than the ++ operator.

Finally, because the assignment operators group from right to left, the statement

a = b = 0;

would be evaluated as

a = (b = 0);

which would have the net result of setting the values of a and b to 0. In the case of the expression

x[i] + ++i

it is not defined whether the compiler will evaluate the left side of the plus operator or the right side first. Here, the way that it’s done affects the result because the value of i might be incremented before x[i] is evaluated.

Another case in which the order of evaluation is not defined is in the expression
shown here:

x[i] = ++i

In this situation, it is not defined whether the value of i will be incremented before or after its value is used to index into x.

The order of evaluation of function and method arguments is also undefined.Therefore, in the function call

f (i, ++i);

or in the message expression

[myFract setTo: i over: ++i];

i might be incremented first, thereby causing the same value to be sent as the two arguments to the function or method.

The Objective-C language guarantees that the && and || operators will be evaluated from left to right. Furthermore, in the case of &&, it is guaranteed that the second operand will not be evaluated if the first is 0; in the case of ||, it is guaranteed that the second operand will not be evaluated if the first is nonzero.This fact is worth considering when forming expressions such as

if ( dataFlag || [myData checkData] )
...

because, in this case, checkData is invoked only if the value of dataFlag is 0.As another example, if the array object a is defined to contain n elements, the statement that begins

if (index >= 0 && index < n && ([a objectAtIndex: index] == 0))
...

references the element contained in the array only if index is a valid subscript into the array.

Constant Expressions

A constant expression is an expression in which each of the terms is a constant value. Constant expressions are required in the following situations:

1. As the value after a case in a switch statement
2. For specifying the size of an array
3. For assigning a value to an enumeration identifier
4. For specifying the bit field size in a structure definition
5. For assigning initial values to external or static variables
6. For specifying initial values to global variables
7. As the expression following the #if in a #if preprocessor statement

In the first four cases, the constant expression must consist of integer constants, character constants, enumeration constants, and sizeof expressions.The only operators that can be used are the arithmetic operators, bitwise operators, relational operators, conditional expression operator, and type cast operator.

In the fifth and sixth cases, in addition to the rules cited earlier, the address operator can be implicitly or explicitly used. However, it can be applied only to external or static variables or functions. So, for example, the expression

&x + 10

would be a valid constant expression, provided that x is an external or static variable. Furthermore, the expression

&a[10] - 5

is a valid constant expression if a is an external or static array. Finally, because &a[0] is equivalent to the expression a

a + sizeof (char) * 100

is also a valid constant expression.

For the last situation that requires a constant expression (after the #if), the rules are the same as for the first four cases, except the sizeof operator, enumeration constants, and type cast operator cannot be used. However, the special defined operator is permitted (see the section “The #if Directive”).

Arithmetic Operators

Given that

the expression

In each expression, the usual arithmetic conversions are performed on the operands (see the section “Conversion of Basic Data Types”). If a is unsigned, -a is calculated by first applying integral promotion to it, subtracting it from the largest value of the promoted type, and adding 1 to the result.

If two integral values are divided, the result is truncated. If either operand is negative, the direction of the truncation is not defined (that is, –3 / 2 can produce –1 on some machines
and –2 on others); otherwise, truncation is always toward 0 (3 / 2 always produces 1). See the section “Basic Operations with Pointers” for a summary of arithmetic operations with pointers.

Logical Operators

Given that

the expression

The usual arithmetic conversions are applied to a and b (see the section “Conversion
of Basic Data Types”). The type of the result in all cases is int.

Relational Operators

Given that

the expression

The usual arithmetic conversions are performed on a and b (see the section “Conversion of Basic Data Types”). The first four relational tests are meaningful for pointers only if they both point into the same array or to members of the same structure or union. The type of the result in each case is int.

Bitwise Operators

Given that

the expression

The usual arithmetic conversions are performed on the operands, except with << and >>, in which case just integral promotion is performed on each operand (see the section “Conversion of Basic Data Types”). If the shift count is negative or is greater than or equal to the number of bits contained in the object being shifted, the result of the shift is undefined. On some machines, a right shift is arithmetic (sign fill) and on others logical (zero fill). The type of the result of a shift operation is that of the promoted left operand.

Increment and Decrement Operators

Given that

the expression

The section “Basic Operations with Pointers” describes these operations on pointers.

Assignment Operators

Given that

the expression

In the first expression, if a is one of the basic data types (except void), it is converted to match the type of l. If l is a pointer, a must be a pointer to the same type as l, a void pointer, or the null pointer.

If l is a void pointer, a can be of any pointer type.The second expression is treated as if it were written l = lop (a), except l is evaluated only once (consider x[i++] += 10).

Conditional Operator

Given that

the expression

Expressions b and c must be of the same data type. If they are not, but are both arithmetic data types, the usual arithmetic conversions are applied to make their types the name. If one is a pointer and the other is 0, the latter is taken as a null pointer of the same type as the former. If one is a pointer to void and the other is a pointer to another type, the latter is converted to be a pointer to void and is the resulting type.

Type Cast Operator

Given that

the expression

Note that the use of a parenthesized type in a method declaration or definition is not
an example of the use of the type cast operator.

sizeof Operator

Given that

the expression

If type is char, the result is defined to be 1. If a is the name of an array that has been imensioned (either explicitly or implicitly through initialization) and is not a formal parameter or undimensioned extern array, sizeof a gives the number of bytes required to
store the elements in a.

If a is the name of a class, sizeof (a) gives the size of the data structure needed to hold an instance of a.

The type of the integer produced by the sizeof operator is size_t, which is defined in the standard header file <stddef.h>.

If a is a variable length array, then the expression is evaluated at runtime; otherwise, it is evaluated at compile time and can be used in constant expressions (refer to the section “Constant Expressions”).

Comma Operator

Given that

the expression

Basic Operations with Arrays

Given that

the expression

In each case, the type of the result is the type of the elements contained in a. See the section “Basic Operations with Pointers” for a summary of operations with pointer and arrays.

Basic Operations with Structures

Note
This also applies to unions.

Given that

the expression

Basic Operations with Pointers

Given that

the expression

Pointers to Arrays

Given that

the expression

The actual type of the integer produced by subtracting two pointers is specified by ptrdiff_t, which is defined in the standard header file <stddef.h>. 

Pointers to Structures

Given that

the expression

Compound Literals

A compound literal is a type name enclosed in parentheses followed by an initialization list. It creates an unnamed value of the specified type, which has scope limited to the block in which it is created, or global scope if defined outside of any block. In the latter case, the initializers must all be constant expressions.
As an example,

(struct point) {.x = 0, .y = 0}

is an expression that produces a structure of type struct point with the specified initial values.This can be assigned to another struct point structure, like so:

origin = (struct point) {.x = 0, .y = 0};

Or it can be passed to a function or method expecting an argument of struct point, like so:

moveToPoint ((struct point) {.x = 0, .y = 0});

Types other than structures can be defined as well—for example, if intPtr is of type int *, the statement

intPtr = (int [100]) {[0] = 1, [50] = 50, [99] = 99 };

(which can appear anywhere in the program) sets intptr pointing to an array of 100 integers, whose 3 elements are initialized as specified.

If the size of the array is not specified, it is determined by the initializer list.

Conversion of Basic Data Types

The Objective-C language converts operands in arithmetic expressions in a predefined order, known as the usual arithmetic conversions:

1. If either operand is of type long double, the other is converted to long double and that is the type of the result.
2. If either operand is of type double, the other is converted to double and that is the type of the result.
3. If either operand is of type float, the other is converted to float and that is the type of the result.
4. If either operand is of type _Bool, char, short int, int bit field, or an enumerated data type, it is converted to int, if an int can fully represent its range of values; otherwise, it is converted to unsigned int. If both operands are of the same type, that is the type of the result.
5. If both operands are signed or both are unsigned, the smaller integer type is converted to the larger integer type and that is the type of the result.
6. If the unsigned operand is equal in size or larger than the signed operand, the signed operand is converted to the type of the unsigned operand, and that is the type of the result.
7. If the signed operand can represent all the values in the unsigned operand, the latter is converted to the type of the former if it can fully represent its range of values, and that is the type of the result.
8. If this step is reached, both operands are converted to the unsigned type corresponding to the type of the signed type.

Step 4 is known more formally as integral promotion.
Conversion of operands is well behaved in most situations, although the following points should be noted:

1. Conversion of a char to an int can involve sign extension on some machines, unless the char is declared as unsigned.
2. Conversion of a signed integer to a longer integer results in extension of the sign to the left; conversion of an unsigned integer to a longer integer results in zero fill to the left.
3. Conversion of any value to a _Bool results in 0 if the value is zero and 1 otherwise.
4. Conversion of a longer integer to a shorter one results in truncation of the integer on the left.
5. Conversion of a floating-point value to an integer results in truncation of the decimal portion of the value. If the integer is not large enough to contain the converted floating-point value, the result is not defined, as is the result of converting a negative floating-point value to an unsigned integer.
6. Conversion of a longer floating-point value to a shorter one might or might not result in rounding before the truncation occurs.