The binary operators are categorized as follows:

- Multiplicative operators: multiplication (*), remainder (%), and division (/) (see Section 6.5.1)
- Additive operators: addition (+) and subtraction (-) (see Section 6.5.2)
- Shift operators: left shift (<<) and right shift (>>) (see Section 6.5.3)
- Relational operators: less than (<), less than or equal to (<=), greater than (>), and greater than or equal to (>=) (see Section 6.5.4)
- Equality operators: equality (==) and inequality (!=) (see Section 6.5.5)
- Bitwise operators: AND (&), OR (|), and XOR (^) (see Section 6.5.6)
- Logical operators: AND (&&) and OR (||) (see Section 6.5.7)

The following sections describe these binary operators.

The multiplicative operators are *, /, and %. Operands must have arithmetic type. Operands are converted, if necessary, according to the usual arithmetic conversion rules (see Section 6.10.1).

The * operator performs multiplication.

The / operator performs division. When integers are divided, truncation is toward zero. If either operand is negative, the result is truncated toward zero (the largest integer of lesser magnitude than the algebraic quotient).

The % operator divides the first operand by the second and yields the remainder. Both operands must be integral. When both operands are unsigned or positive, the result is positive. If either operand is negative, the sign of the result is the same as the sign of the left operand.

The following statement is true if `b`

is not zero:

(a/b)*b + a%b == a;

The DEC C compiler, with the check option enabled, issues warnings for these undefined behaviors:

- Integer overflow occurs
- Division by zero is attempted
- Remainder by zero is attempted

The additive operators + and - perform addition and subtraction. Operands are converted, if necessary, according to the usual arithmetic conversion rules (see Section 6.10.1).

When two `enum`

constants or variables are added or
subtracted, the type of the result is `int`

.

When an integer is added to or subtracted from a pointer expression, the integer is scaled by the size of the object being pointed to. The result has the pointer's type. For example:

int arr[10]; int *p = arr; p = p + 1; /* Increments by sizeof(int) */

An array pointer can be decremented by subtracting an integral value from a pointer or address; the same conversions apply as for addition. Pointer arithmetic also applies one element beyond the end of the array. For example, the following code works because the pointer arithmetic is limited to the elements of the array and to only one element beyond:

int i = 0; int x[5] = {0,1,2,3,4}; int y[5]; int *ptr = x; while (&y[i] != (ptr + 5)) { /* ptr + 5 marks one beyond the end of the array */ y[i] = x[i]; i++; }

When two pointers to elements of the same array are subtracted,
the result (calculated by dividing the difference between
the two addresses by the length of one element) is of type
`ptrdiff_t`

, which in DEC C is `int`

, and represents the
number of elements between the two addressed elements. If the two
elements are not in the same array, the result of this operation is
undefined.

The shift operators << and >> shift their left operand to the left or to the right, respectively, by the number of bits specified by the right operand. Both operands must be integral. The compiler performs integral promotions on each of the operands (see Section 6.10.1.1). The type of the result is the type of the promoted left operand. Consider the following expression:

E1<<E2

The result is the value of expression *E1* shifted to the
left by *E2* bits. Bits shifted off the end are lost.
Vacated bits are filled with zeros. The effect of shifting left
is to multiply the left operand by 2 for each bit shifted. In the
following example, the value of `i`

is 100:

int n = 25; int m = 2; int i; i = n << m;

Consider the following expression:

E1>>E2

The result is the value of expression *E1* shifted to the
right by *E2* bits. Bits shifted off the end are lost. If
*E1* is `unsigned`

or if *E1* has a signed
type but nonnegative value, vacated bits are filled with zeros.
If *E1* has a signed type and negative
value, vacated bits are filled with ones.

The result of the shift operation is undefined if the right operand
is negative or if its value is greater than the number of bits in an
`int`

.

For a nonnegative left operand, the effect of shifting right is to
divide the left operand by 2 for each bit shifted. In the following
example, the value of `i`

is 12:

int n = 100; int m = 3; int i; i = n >> m;

The relational operators compare two operands and produce a result
of type `int`

. The result is 0 if the relation is
false, and 1 if it is true. The operators are: less than (<),
greater than (>), less than or equal (<=), and greater than
or equal (>=). Both operands must have an arithmetic type or
must be pointers to compatible types. The compiler performs the
necessary arithmetic conversions before the comparison (see Section 6.10.1).

When two pointers are compared, the result depends on the relative locations of the two addressed objects. Pointers to objects at lower addresses are less than pointers to objects at higher addresses. If two addresses indicate elements in the same array, the address of an element with a lower subscript is less than the address of an element with a higher subscript.

The relational operators associate from left to right. Therefore,
the following statement relates `a`

to `b`

, and if `a`

is less than `b`

, the result
is 1 (true). If `a`

is greater than or equal to
`b`

, the result is 0 (false). Then, 0 or 1 is compared
with `c`

for the expression result. This statement does
not determine "if `b`

is between `a`

and
`c`

".

if ( a < b < c ) statement;

To check if `b`

is between `a`

and
`c`

, use the following code:

if ( a < b && b < c ) statement;

The equality operators, equal (==) and not-equal (!=), produce
a result of type `int`

, so that the result of the
following statement is 1 if both operands have the same value, and 0
if they do not:

a == b

Operands must have one of the following type combinations:

- Both operands have an arithmetic type.
- Both operands are pointers to qualified or unqualified versions of compatible types.
- One operand is a pointer to an object or incomplete type
and the other is a pointer to a qualified or unqualified version
of
`void`

. - One operand is a pointer and the other is a null pointer constant.

Operands are converted, if necessary, according to the usual arithmetic conversion rules (see Section 6.10.1).

Two pointers or addresses are equal if they identify the same storage location.

**Note**- Although different symbols
are used for assignment (=) and equality (==), C allows either
operator in all contexts, so be careful not to confuse them.
Consider the following example:
if ( x = 1 )

In this example,*statement_1*; else*statement_2*;`statement_1`

always executes, because the result of the assignment`x = 1`

is equivalent to the value of`x`

, which equals 1 (or true).

The bitwise operators require integral operands. The usual arithmetic conversions are performed (see Section 6.10.1). The result of the expression is the bitwise AND (&), inclusive OR (|), or exclusive OR (^), of the two operands. The order of evaluation of their operands is not guaranteed.

The operands are evaluated bit by bit. The result of the & operator is 0 if one bit value is 0 and the other is 1, or if both bit values are 0. The result is 1 if both bit values are 1.

The result of the | operator is 0 if both bit values are 0. The result for each bit is 1 if either bit value is 1, or both bit values are 1.

The result of the ^ operator is 0 if both bit values are 0, or if both bit values are 1. The result for each bit is 1 if either bit value is 1 and the other is 0.

The logical operators are AND (&&) and OR (||). These operators
guarantee left-to-right evaluation. The result of the expression
(of type `int`

) is either 0 (false) or 1 (true). The
operands need not have the same type, but both types must be scalar.
If the compiler can make an evaluation by examining only the left
operand, the right operand is not evaluated. Consider the following
expression:

E1&&E2

The result of this expression is 1 if both operands are nonzero, or
0 if one operand is 0. If expression *E1* is 0, expression
*E2* is not evaluated because the result is the same
regardless of *E2*'s value.

Similarly, the following expression is 1 if either operand is
nonzero, and 0 otherwise. If expression *E1* is nonzero,
expression *E2* is not evaluated, because the result is the
same regardless of *E2*'s value.

E1||E2

Previous Page | Next Page | Table of Contents | Index