Standard arithmetic

The operands are subject to the usual arithmetic conversions (see “Conversion of Arithmetic Types”). The result of division with two integer operands is also an integer! To obtain the remainder of an integer division, use the modulo operation (the % operator). Implicit type conversion takes place in the evaluation of the following expressions, as shown in Table 5-6 (assume n is declared by short n = -5;).

If both operands in a multiplication or a division have the same sign, the result is positive; otherwise, it is negative. However, the result of a modulo operation always has the same sign as the left operand. For this reason, the expression 8%n in Table 5-6 yields the value 3. If a program attempts to divide by zero, its behavior is undefined.

Pointer arithmetic

You can use the binary operators + and - to perform arithmetic operations on pointers. For example, you can modify a pointer to refer to another object a certain number of object sizes away from the object originally referenced. Such pointer arithmetic is generally useful only to refer to the elements of an array.

Adding an integer to or subtracting an integer from a pointer yields a pointer value with the same type as the pointer operand. The compiler automatically multiplies the integer by the size of the object referred to by the pointer type, as Example 5-1 illustrates.

double dArr[5] = { 0.0, 1.1, 2.2, 3.3, 4.4 },  // Initialize an array and
       *dPtr = dArr;                           // a pointer to its first
                                               // element.
int i = 0;                       // An index variable.

dPtr = dPtr + 1;                 // Advance dPtr to the second element.
dPtr = 2 + dPtr;                 // Addends can be in either order.
                                 // dPtr now points to dArr[3].

printf( "%.1f\n", *dPtr );       // Print the element referenced by dPtr.
printf( "%.1f\n", *(dPtr -1) );  // Print the element before that, without
                                 // modifying the pointer dPtr.

i = dPtr − dArr;                 // Result: the index of the
                                 // array element that dPtr points to.

Figure 5-1 illustrates the effects of the two assignment expressions using the pointer dPtr.

Figure 5-1. Using a pointer to move through the elements in an array

The statement dPtr = dPtr + 1; adds the size of one array element to the pointer, so that dPtr points to the next array element, dArr[1]. Because dPtr is declared as a pointer to double, its value is increased by sizeof(double).

The statement dPtr = dPtr + 1; in Example 5-1 has the same effect as any of the following statements (see “Assignment Operators” and “Increment and Decrement Operators”):

dPtr += 1;
++dPtr;
dPtr++;

Subtracting one pointer from another yields an integer value with the type ptrdiff_t. The value is the number of objects that fit between the two pointer values. In the last statement in Example 5-1, the expression dPtr − dArr yields the value 3. This is also the index of the element that dPtr points to, because dArr represents the address of the first array element (with the index 0). The type ptrdiff_t is defined in the header file stddef.h, usually as int.

For more information on pointer arithmetic, see Chapter 9.

Simple assignment

The operands of a simple assignment must fulfill one of the following conditions:

• Both operands have arithmetic types.

• The left operand has the type _Bool and the right operand is a pointer.

• Both operands have the same structure or union type.

• Both operands are pointers to the same type, or the left operand is a pointer to a qualified version of the common type—that is, the type pointed to by the left operand is declared with one or more additional type qualifiers (see Chapter 11).

• One operand is an object pointer and the other is a pointer to void (here again, the type pointed to by the left operand may have additional type qualifiers).

• The left operand is a pointer and the right is a null pointer constant.

If the two operands have different types, the value of the right operand is converted to the type of the left operand (see “The Results of Arithmetic Type Conversions” and “Implicit Pointer Conversions”).

The modification of the left operand is a side effect of an assignment expression. The value of the entire assignment expression is the same as the value assigned to the left operand, and the assignment expression has the type of the left operand. However, unlike its left operand, the assignment expression itself is not an lvalue. If you use the value of an assignment expression in a larger expression, pay careful attention to implicit type conversions. Avoid errors such as that illustrated in the following example. This code is supposed to read characters from the standard input stream until the end-of-file is reached or an error occurs:

#include <stdio.h>
char c = 0;

/* ... */

while ( (c = getchar()) != EOF )
  { /* ... Process the character stored in c ... */ }

In the controlling expression of the while statement in this example, getchar() returns a value with type int, which is implicitly converted to char for assignment to c. Then the value of the entire assignment expression c = getchar(), which is the same char value, is promoted to int for comparison with the constant EOF, which is usually defined as -1 in the header file stdio.h. However, if the type char is equivalent to unsigned char, then the conversion to int always yields a non-negative value. In this case, the loop condition is always true.

As Table 5-4 shows, assignment operators have a low precedence, and are grouped with their operators from right to left. As a result, no parentheses are needed around the expression to the right of the assignment operator, and multiple assignments can be combined in one expression, as in this example:

double x = 0.5, y1, y2;      // Declarations
y1 = y2 = 10.0 * x;          // Equivalent to  y1 = (y2 = (10.0 * x));

This expression assigns the result of the multiplication to y1 and to y2.

Compound assignments

A compound assignment is performed by any of the following operators:

 *=  /= %= += -=  (arithmetic operation and assignment)
<<= >>= &= ^= |=  (bitwise operation and assignment)

In evaluating a compound assignment expression, the program combines the two operands with the specified operation and assigns the result to the left operand. Here are two examples:

long var = 1234L ;
var *= 3;        // Triple the value of var.
var <<= 2;       // Shift the bit pattern in var two bit-positions
                 // to the left (i.e., multiply the value by four).

The only difference between a compound assignment x op= y and the corresponding expression x = x op (y) is that in the compound assignment, the left operand x is evaluated only once. In the following example, the left operand of the compound assignment operator is an expression with a side effect, so that the two expressions are not equivalent:

x[++i] *= 2;              // Increment i once, then double the indexed
                          // array element.
x[++i] = x[++i] * (2);    // Oops: you probably didn't want to
                          // increment i twice.

In the equivalent form x = x op (y), the parentheses around the right operand y are significant, as the following example illustrates:

double var1 = 2.5, var2 = 0.5;
var1 /= var2 + 1;         // Equivalent to var1 = var1 / (var2 + 1);

Without the parentheses, the expression var1 = var1 / var2 + 1 would yield a different result, because simple division, unlike the compound assignment, has higher precedence than addition.

The operands of a compound assignment can have any types that are permissible for the operands of the corresponding binary operator. The only additional restriction is that when you add a pointer to an integer, the pointer must be the left operand, as the result of the addition is a pointer. For example:

short *sPtr;
/* ... */
sPtr += 2;         // Equivalent to  sPtr = sPtr + 2;
                   // or  sPtr = 2 + sPtr;

Boolean bitwise operators

The operators listed in Table 5-11 perform Boolean operations on each bit position of their operands. The binary operators connect the bit in each position in one operand with the bit in the same position in the other operand. A bit that is set, or 1, is interpreted as true, and a bit that is cleared, or 0, is considered false.

In addition to the operators for boolean AND, OR, and NOT, there is also a bitwise exclusive-OR operator. These are all described in Table 5-11.

The operands of the bitwise operators must have integer types, and are subject to the usual arithmetic conversions. The resulting common type of the operands is the type of the result. Table 5-12 illustrates the effects of these operators.

You can clear certain bits in an integer variable a by performing a bitwise AND with an integer in which only the bits to be cleared contain zeros, and assigning the result to the variable a. The bits that were set in the second operand—called a bit mask—have the same value in the result as they had in the first operand. For example, an AND with the bit mask 0xFF clears all bits except the lowest eight:

a &= 0xFF;       // Equivalent notation: a = a & 0xFF;

As this example illustrates, the compound assignment operator &= also performs the & operation. The compound assignments with the other binary bitwise operators work similarly.

The bitwise operators are also useful in making bit masks to use in further bit operations. For example, in the bit pattern of 0x20, only bit 5 is set. The expression ~0x20 therefore yields a bit mask in which all bits are set except bit 5:

a &= ~0x20;    // Clear bit 5 in a.

The bit mask ~0x20 is preferable to 0xFFFFFFDF because it is more portable: it gives the desired result regardless of the machine’s word size. (It also makes the statement more readable for humans.)

You can also use the operators | (OR) and ^ (exclusive OR) to set and clear certain bits. Here is an example of each one:

int mask = 0xC;
a |= mask;       // Set bits 2 and 3 in a.
a ^= mask;       // Invert bits 2 and 3 in a.

A second inversion using the same bit mask reverses the first inversion. In other words, b^mask^mask yields the original value of b. This behavior can be used to swap the values of two integers without using a third, temporary variable:

a ^= b;          // Equivalent to a = a ^ b;
b ^= a;          // Assign b the original value of a.
a ^= b;          // Assign a the original value of b.

The first two expressions in this example are equivalent to b = b^(a^b) or b = (a^b)^b. The result is like b = a, with the side effect that a is also modified, and now equals a^b. At this point, the third expression has the effect of (using the original values of a and b) a = (a^b)^a, or a = b.

Shift operators

The shift operators transpose the bit pattern of the left operand by the number of bit positions indicated by the right operand. They are listed in Table 5-13.

The operands of the shift operators must be integers. Before the actual bit-shift, the integer promotions are performed on both operands. The value of the right operand must not be negative, and must be less than the width of the left operand after integer promotion. If it does not meet these conditions, the program’s behavior is undefined.

The result has the type of the left operand after integer promotion. The shift expressions in the following example have the type unsigned long.

unsigned long n = 0xB,    // Bit pattern:  0 ... 0 0 0 1 0 1 1
         result = 0;
result = n << 2;          //               0 ... 0 1 0 1 1 0 0
result = n >> 2;          //               0 ... 0 0 0 0 0 1 0

In a left shift, the bit positions that are vacated on the right are always cleared. Bit values shifted beyond the leftmost bit position are lost. A left shift through y bit positions is equivalent to multiplying the left operand by 2^y: if the left operand x has an unsigned type, then the expression x << y yields the value of x × 2^y. Thus, in the previous example, the expression n << 2 yields the value of n × 4, or 44.

On a right shift, the vacated bit positions on the left are cleared if the left operand has an unsigned type, or if it has a signed type and a non-negative value. In this case, the expression x >> y yields the same value as the integer division x/2^y. If the left operand has a negative value, then the fill value depends on the compiler: it may be either zero or the value of the sign bit.

The shift operators are useful in generating certain bit masks. For example, the expression 1 << 8 yields a word with only bit 8 set, and the expression ~(3<<4) produces a bit pattern in which all bits are set except bits 4 and 5. The function setBit() in Example 5-3 uses the bit operations to manipulate a bit mask.

// Function setBit()
// Sets the bit at position p in the mask m.
// Uses CHAR_BIT, defined in limits.h, for the number of bits in a byte.
// Return value: The new mask with the bit set, or the original mask
//               if p is not a valid bit position.
unsigned int setBit( unsigned int mask, unsigned int p )
{
  if ( p >= CHAR_BIT * sizeof(int) )
    return mask;
  else
    return mask | (1 << p);
}

The shift operators have lower precedence than the arithmetic operators but higher precedence than the comparative operators and the other bitwise operators. The parentheses in the expression mask | (1 << p) in Example 5-3 are thus actually unnecessary, but they make the code more readable.

The & and * operators

The address operator & yields the address of its operand. If the operand x has the type T, then the expression &x has the type “pointer to T.”

The operand of the address operator must have an addressable location in memory. In other words, the operand must designate either a function or an object (i.e., an lvalue) that is not a bit-field, and has not been declared with the storage class register (see “Storage Class Specifiers”).

You need to obtain the addresses of objects and functions when you want to initialize pointers to them:

float x, *ptr;
ptr = &x;         // OK: Make ptr point to x.
ptr = &(x+1);     // Error: (x+1) is not an lvalue.

Conversely, when you have a pointer and want to access the object it references, use the indirection operator *, which is sometimes called the dereferencing operator (see “Using Pointers to Read and Modify Objects” for more information). Its operand must have a pointer type. If ptr is a pointer, then *ptr designates the object or function that ptr points to. If ptr is an object pointer, then *ptr is an lvalue, and you can use it as the left operand of an assignment operator:

float x, *ptr = &x;
*ptr = 1.7;          // Assign the value 1.7 to the variable x
++(*ptr);            // and add 1 to it.

In the final statement of this example, the value of ptr remains unchanged. The value of x is now 2.7.

The behavior of the indirection operator * is undefined if the value of the pointer operand is not the address of an object or a function.

Like the other unary operators, the operators & and * have the second highest precedence. They are grouped with operands from right to left. The parentheses in the expression ++(*ptr) are thus superfluous.

The operators & and * are complementary: if x is an expression that designates an object or a function, then the expression *&x is equivalent to x. Conversely, in an expression of the form &*ptr, the operators cancel each other out so that the type and value of the expression are equivalent to ptr. However, &*ptr is never an lvalue, even if ptr is.

Elements of arrays

The subscript operator [] allows you to access individual elements of an array. It takes two operands. In the simplest case, one operand is an array name and the other operand designates an integer. In the following example, assume that myarray is the name of an array, and i is a variable with an integer type. The expression myarray[i] then designates element number i in the array, where the first element is element number zero (see Chapter 8).

The left operand of [] need not be an array name. One operand must be an expression whose type is “pointer to an object type”—an array name is a special case of such an expression—while the other operand must have an integer type. An expression of the form x[y] is always equivalent to (*((x)+(y))) (see also “Pointer arithmetic” earlier in this chapter). Example 5-4 uses the subscript operator in initializing a dynamically generated array.

#include <stdlib.h>
#define ARRAY_SIZE 100
/* ... */
double *pArray = NULL; int i = 0;
pArray = malloc( ARRAY_SIZE * sizeof(double) ); // Generate the array
if ( pArray != NULL ) {
   for ( i = 0; i < ARRAY_SIZE; ++i )           // and initialize it.
     pArray[i] = (double)rand()/RAND_MAX;
/* ... */
}

In Example 5-4, the expression pArray[i] in the loop body is equivalent to *(pArray+i). The notation i[pArray] is also correct, and yields the same array element.

Members of structures and unions

The binary operators . and ->, most often called the dot operator and the arrow operator, allow you to select a member of a structure or a union.

As Example 5-5 illustrates, the left operand of the dot operator . must have a structure or union type, and the right operand must be the name of a member of that type.

struct Article { long number;      // The part number of an article
                 char name[32];    // The article's name
                 long price;       // The unit price in cents
                 /* ... */
               };
struct Article sw = { 102030L, "Heroes", 5995L };
sw.price = 4995L;                  // Change the price to 49.95

The result of the dot operator has the value and type of the selected member. If the left operand is an lvalue, then the operation also yields an lvalue. If the left operand has a qualified type (such as one declared with const), then the result is likewise qualified.

The left operand of the dot operator is not always an lvalue, as the following example shows:

struct Article getArticle();       // Function prototype
printf( "name: %s\n", getArticle().name );

The function getArticle() returns an object of type struct Article. As a result, getArticle().name is a valid expression, but not an lvalue, as the return value of a function is not an lvalue.

The operator -> also selects a member of a structure or union, but its left operand must be a pointer to a structure or union type. The right operand is the name of a member of the structure or union. Example 5-6 illustrates the use of the -> operator, again using the Article structure defined in Example 5-5.

struct Article *pArticle = &sw,         // A pointer to struct Article.
       const *pcArticle = &sw;          // A "read-only pointer" to struct
                                        // Article.
++(pArticle->number);                   // Increment the part number.
if ( pcArticle->number == 102031L )     // Correct usage: read-only access.
  pcArticle->price += 50;               // Error: can't use a
                                        // const-qualified pointer
                                        // to modify the object.

The result of the arrow operator is always an lvalue. It has the type of the selected member, as well as any type qualifications of the pointer operand. In Example 5-6, pcArticle is a pointer to const struct Article. As a result, the expression pcArticle->price is constant.

Any expression that contains the arrow operator can be rewritten using the dot operator by dereferencing the pointer separately: an expression of the form p->m is equivalent to (*p).m. Conversely, the expression x.m is equivalent to (&x)->m, as long as x is an lvalue.

The operators . and ->, like [], have the highest precedence, and are grouped from left to right. Thus, the expression ++p->m, for example, is equivalent to ++(p->m), and the expression p->m++ is equivalent to (p->m)++. However, the parentheses in the expression (*p).m are necessary, as the dereferencing operator * has a lower precedence. The expression *p.m would be equivalent to *(p.m), and thus makes sense only if the member m is also a pointer.

To conclude this section, we can combine the subscript, dot, and arrow operators to work with an array whose elements are structures:

struct Article arrArticle[10];     // An array with ten elements
                                   // of type struct Article.
arrArticle[2].price = 990L;        // Set the price of the
                                   // array element arrArticle[2].
arrArticle->number = 10100L;       // Set the part number in the
                                   // array element arrArticle[0].

An array name, such as arrArticle in the example, is a constant pointer to the first array element. Hence arrArticle->number designates the member number in the first array element. To put it in more general terms: for any index i, the following three expressions are equivalent:

arrArticle[i].number
(arrArticle+i)->number
(*(arrArticle+i)).number

All of them designate the member number in the array element with the index i.

Function calls

A function call is an expression of the form fn_ptr(argument_list ), where the operand fn_ptr is an expression with the type “pointer to a function.” If the operand designates a function (as a function name does, for example), then it is automatically converted into a pointer to the function. A function call expression has the value and type of the function’s return value. If the function has no return value, the function call has the type void.

Before you can call a function, you must make sure that it has been declared in the same translation unit. Usually a source file includes a header file containing the function declaration, as in this example:

#include <math.h>    // Contains the prototype
                     // double pow( double, double );
double x = 0.7, y = 0.0;
/* ... */
y = pow( x+1, 3.0 );    // Type: double

The parentheses enclose the comma-separated list of arguments passed to the function, which can also be an empty list. If the function declaration is in prototype form (as is usually the case), the compiler ensures that each argument is converted to the type of the corresponding parameter, as for an assignment. If this conversion fails, the compiler issues an error message:

pow( x, 3 );     // The integer constant 3 is converted to type double.
pow( x );        // Error: incorrect number of arguments.

The order in which the program evaluates the individual expressions that designate the function and its arguments is not defined. As a result, the behavior of a printf statement such as the following is undefined:

int i = 0;
printf( "%d %d\n", i, ++i );     // Behavior undefined

However, there is a sequence point after all of these expressions have been evaluated and before control passes to the function.

Like the other postfix operators, a function call has the highest precedence, and is grouped with operands from left to right. For example, suppose that fn_table is an array of pointers to functions that take no arguments and return a structure that contains a member named price. In this case, the following expression is a valid function call:

fn_table[i++]().price

The expression calls the function referenced by the pointer stored in fn_table[i]. The return value is a structure, and the dot operator selects the member price in that structure. The complete expression has the value of the member price in the return value of the function fn_table[i](), and the side effect that i is incremented once.

Chapter 7 describes function calls in more detail, including recursive functions and functions that take a variable number of arguments.

Compound literals

Compound literals are an extension introduced in the C99 standard. This extension allows you to define literals with any object type desired. A compound literal consists of an object type in parentheses, followed by an initialization list in braces:

(type name ){ list of initializers }

The value of the expression is an unnamed object that has the specified type and the values listed. If you place a compound literal outside of all function blocks, then the initializers must be constant expressions, and the object has static storage duration. Otherwise, it has automatic storage duration, determined by the containing block.

Typical compound literals generate objects with array or structure types. Here are a few examples to illustrate their use:

float *fPtr = (float []){ -0.5, 0.0, +0.5 };

This declaration defines a pointer to a nameless array of three float elements:

#include "database.h"   // Contains prototypes and type definitions,
                        // including the structure Pair:
                        // struct Pair { long key; char value[32]; };

insertPair( &db, &(struct Pair){ 1000L, "New York JFK Airport" } );

This statement passes the address of a literal of type struct Pair to the function insertPair(). You can also store the address in a local variable first:

struct Pair p1 = { 1000L, "New York JFK Airport" };
insertPair( &db, &p1 );

To define a constant compound literal, use the type qualifier const:

(const char [ ]){"A constant string."}

If the previous expression appears outside of all functions, it defines a static array of char, like the following simple string literal:

"A constant string."

In fact, the compiler may store string literals and constant compound literals with the same type and contents at the same location in memory.

Despite their similar appearance, compound literals are not the same as cast expressions. The result of a cast expression has a scalar type or the type void, and is not an lvalue.

The sizeof operator

The sizeof operator yields the size of its operand in bytes. Programs need to know the size of objects mainly in order to reserve memory for them dynamically, or to store binary data in files.

The operand of the sizeof operator can be either an object type in parentheses or an expression that has an object type and is not a bit-field. The result has the type size_t, which is defined in stddef.h and other standard header files as an unsigned integer type.

For example, if i is an int variable and iPtr is a pointer to int, then each of the following expressions yields the size of int—on a 32-bit system, the value would be 4:

sizeof(int)  sizeof i  sizeof(i)  sizeof *iPtr  sizeof(*iPtr)

Note the difference to the following expressions, each of which yields the size of a pointer to int:

sizeof(int*)  sizeof &i  sizeof(&i)  sizeof iPtr  sizeof(iPtr)

Like *, &, and the other unary operators, sizeof has the second highest precedence, and is grouped from right to left. For this reason, no parentheses are necessary in the expression sizeof *iPtr.

For an operand with the type char, unsigned char, or signed char, the sizeof operator yields the value 1, because these types have the size of a byte. If the operand has a structure type, the result is the total size that the object occupies in memory, including any gaps that may occur due to the alignment of the structure members. In other words, the size of a structure is sometimes greater than the sum of its individual members’ sizes. For example, if variables of the type short are aligned on even byte addresses, the following structure has the size sizeof(short) + 2:

struct gap { char version; short value; };

In the following example, the standard function memset() sets every byte in the structure to zero, including any gaps between members:

#include <string.h>
/* ... */
struct gap g;
memset( &g, 0, sizeof g );

If the operand of sizeof is an expression, it is not actually evaluated. The compiler determines the size of the operand by its type, and replaces the sizeof expression with the resulting constant. Variable-length arrays, introduced in the C99 standard, are an exception (see Chapter 8). Their size is determined at runtime, as Example 5-7 illustrates.

void func( float a[ ], int n )
{
  float b[2*n];                    // A variable-length array of float.
  /* ... the value of n may change now ... */
  int m = sizeof(b) / sizeof(*b);  // Yields the number of elements
  /* ... */                        // in the array b.
}

Regardless of the current value of the variable n, the expression sizeof(b) yields the value of 2 × n₀ × sizeof(float), where n₀ is the value that n had at the beginning of the function block. The expression sizeof(*b) is equivalent to sizeof(b[0]), and in this case has the value of sizeof(float).

The _Alignof operator

The alignment of a type describes how objects of that type can be positioned in memory (see “The Alignment of Objects in Memory”). Alignment is expressed as an integer value. The operand of _Alignof is the name of a type in parentheses, and the resulting expression yields the type’s alignment, as in the following example:

_Alignof(char*)    // The alignment of a char pointer

Because the alignment of types is determined by the compiler, _Alignof expressions, like sizeof expressions, are integer constants with the type size_t. If your program includes the header file stdalign.h, you can also use the synonym alignof in place of the keyword _Alignof. The _Alignof operator can only be applied to complete object types, not to function types or incomplete object types. If the operand is an array type, _Alignof yields the alignment of the array elements’ type.

The conditional operator

The conditional operator is sometimes called the ternary or trinary operator, because it is the only one that has three operands:

condition ? expression 1 : expression 2

The operation first evaluates the condition. Then, depending on the result, it evaluates one or the other of the two alternative expressions.

There is a sequence point after the condition has been evaluated. If the result is not equal to 0 (in other words, if the condition is true), then only the second operand, expression 1, is evaluated, and the entire operation yields the value of expression 1. On the other hand, if condition does yield 0 (i.e., false), then only the third operand, expression 2, is evaluated, and the entire operation yields the value of expression 2. In this way, the conditional operator represents a conditional jump in the program flow, and is therefore an alternative to some if-else statements.

A common example is the following function, which finds the maximum of two numbers:

inline int iMax(int a, int b) { return a >= b ? a : b; }

The function iMax() can be rewritten using an if-else statement:

inline int iMax(int a, int b)
{ if ( a >= b ) return a;  else return b; }

The conditional operator has a very low precedence: only the assignment operators and the comma operator are lower. Thus, the following statement requires no parentheses:

distance = x < y ? y − x : x − y;

The first operand of the conditional operator, condition, must have a scalar type—that is, an arithmetic type or a pointer type. The second and third operands, expression 1 and expression 2, must fulfill one of the following cases:

• Both of the alternative expressions have arithmetic types, in which case the result of the complete operation has the type that results from performing the usual arithmetic conversions on these operands.

• Both of the alternative operands have the same structure or union type, or the type void. The result of the operation also has this type.

• Both of the alternative operands are pointers, and one of the following is true:

  • Both pointers have the same type. The result of the operation then has this type as well.

  • One operand is a null pointer constant. The result then has the type of the other operand.

  • One operand is an object pointer and the other is a pointer to void. The result then has the type void *.

The two pointers may point to differently qualified types. In this case, the result is a pointer to a type that has all of the type qualifiers of the two alternative operands. For example, suppose that the following pointers have been defined:

const int *cintPtr;           // Declare pointers
volatile int *vintPtr;
void *voidPtr;

The expressions in the following table then have the type indicated, regardless of the truth value of the variable flag:

The comma operator

The comma operator is a binary operator:

expression 1 , expression 2

The comma operator ensures sequential processing: first the left operand is evaluated, then the right operand. The result of the complete expression has the type and value of the right operand. The left operand is only evaluated for its side effects; its value is discarded. There is a sequence point after the evaluation of the left operand. For example:

x = 2.7, sqrt( 2*x )

In this expression, the assignment takes place first, before the sqrt() function is called. The value of the complete expression is the function’s return value.

The comma operator has the lowest precedence of all operators. For this reason, the assignment x = 2.7 in the previous example does not need to be placed in parentheses. However, parentheses are necessary if you want to use the result of the comma operation in another assignment:

y = ( x = 2.7, sqrt( 2*x ));

This statement assigns the square root of 5.4 to y.

A comma in a list of initializers or function arguments is a list separator, not a comma operator. In such contexts, however, you can still use a comma operator by enclosing an expression in parentheses:

y = sqrt( (x=2.7, 2*x) );

This statement is equivalent to the one in the previous example. The comma operator allows you to group several expressions into one. This ability makes it useful for initializing or incrementing multiple variables in the head of a for loop, as in the following example:

int i;  float fArray[10], val;
for ( i=0, val=0.25;  i < 10;  ++i, val *= 2.0 )
   fArray[i] = val;