Chapter 4: Operators

C# provides an extensive set of operators that give the programmer detailed control over the construction and evaluation of expressions. Most of C#’s operators fall into the following categories: arithmetic, bitwise, relational, and logical. These operators are examined in this chapter. Also discussed are the assignment operator and the ? operator. C# also defines several other operators that handle specialized situations, such as array indexing and member access. These special operators are examined later in this book, when the features to which they apply are discussed.

Arithmetic Operators

C# defines the following arithmetic operators:

Operator	Meaning
+	; Addition
−	Subtraction (also unary minus)
*	Multiplication
/	Division
%	Modulus
++	Increment
−−	Decrement

The operators +, −, *, and / all work the same way in C# as they do in any other computer language (or in algebra, for that matter). These can be applied to any built-in numeric data type.

Although the actions of arithmetic operators are well known to all readers, a few special situations warrant some explanation. First, remember that when / is applied to an integer, any remainder will be truncated; for example, 10/3 will equal 3 in integer division. You can obtain the remainder of this division by using the modulus operator, %. The % is also referred to as the remainder operator. It yields the remainder of an integer division. For example, 10 % 3 is 1. In C#, the % can be applied to both integer and floating-point types.

Thus, 10.0 % 3.0 is also 1. (This differs from C/C++, which allow modulus operations only on integer types.) The following program demonstrates the modulus operator:

 // Demonstrate the % operator, using System; class ModDemo {   public static void Main() {     int iresult, irem;     double dresult, drem;     iresult = 10 / 3;     irem = 10 % 3;     dresult = 10.0 / 3.0;     drem = 10.0 % 3.0;     Console.WriteLine("Result and remainder of 10 / 3: " +                        iresult + " " + irem);     Console.WriteLine("Result and remainder of 10.0 / 3.0: " +                        dresult + " " + drem);   } }

The output from the program is shown here:

 Result and remainder of 10 / 3: 3 1 Result and remainder of 10.0 / 3.0: 3.33333333333333 1

As you can see, the % yields a remainder of 1 for both integer and floating-point operations.

Increment and Decrement

Introduced in Chapter 2, the ++ and the −− are the increment and decrement operators. As you will see, they have some special properties that make them quite interesting. Let’s begin by reviewing precisely what the increment and decrement operators do.

The increment operator adds 1 to its operand, and the decrement operator subtracts 1. Therefore,

 x = x + 1;

is the same as

 x++;

and

 x = x − 1;

is the same as

 x−−;   

Both the increment and decrement operators can either precede (prefix) or follow (postfix) the operand. For example:

 x = x + 1;

can be written as

 ++x; // prefix form

or as

 x++; // postfix form

In the foregoing example, there is no difference whether the increment is applied as a prefix or a postfix. However, when an increment or decrement is used as part of a larger expression, there is an important difference. When an increment or decrement operator precedes its operand, C# will perform the operation prior to obtaining the operand’s value for use by the rest of the expression. If the opera tor follows its operand, then C# will obtain the operand's value before incrementing or decrementing it. Consider the following:

 x = 10; y = ++x;

In this case, y will be set to 11. However, if the code is written as

 x = 10; y = x++;

then y will be set to 10. In both cases, x is still set to 11; the difference is when it happens.

There are significant advantages in being able to control when the increment or decrement operation takes place. Consider the following program, which generates a series of numbers:

 /*    Demonstrate the difference between prefix    postfix forms of ++. */ using System; class PrePostDemo {   public static void Main() {     int x, y;     int i;     x = 1;     Console.WriteLine("Series generated using y = x + x++;");     for(i = 0; i < 10; i++) {       y = x + x++; // postfix ++       Console.WriteLine(y + " ");     }     Console.WriteLine();     x = 1;     Console.WriteLine("Series generated using y = x + ++x;");     for(i = 0; i < 10; i++) {       y = x + ++x; // prefix ++       Console.WriteLine(y + " ");     }     Console.WriteLine();   } }

The output is shown here:

 Series generated using y = x + x++; 2 4 6 8 10 12 14 16 18 20 Series generated using y = x + ++x; 3 5 7 9 11 13 15 17 19 21

As the output confirms, the statement

 y = x + x++;

adds the value of x to x and assigns that result to y. It then increments x. However, the statement

 y = x + ++x;

obtains the value of x, then increments x, and then adds that value to the original value of x. The result is assigned to y. As the output shows, simply changing x++ to ++x changes the number series from even to odd.

One other point about the preceding example: Don't let expressions like

 x + ++x

intimidate you. Although having two operators back-to-back is a bit unsettling at first glance, the compiler keeps it all straight. Just remember, this expression simply adds the value of x to the value of x incremented.