### 2.3. Operators: Arithmetic, Logical, and Conditional

The C# operators used for arithmetic operations, bit manipulation, and conditional program flow should be familiar to all programmers. This section presents an overview of these operators that is meant to serve as a syntactical reference.

#### Arithmetic Operators

Table 2-4 summarizes the basic numerical operators. The precedence in which these operators are applied during the evaluation of an expression is shown in parentheses, with 1 being the highest precedence.

##### Table 2-4. Numerical Operators

Operator

Description

Example

```
+

-

```

(3)

Subtraction

int x = y + 10;

```
*

/

%

```

(2)

Multiplication

Division,

Modulo

```
int x = 60;

int y = 15;

int z = x * y / 2;  // 450

y = x % 29 ;  // remainder is 2

```

```
++

--

```

(1)

Prefix/postfix

Increment/decrement

```
x = 5;

Console.WriteLine(x++) // x = 5

Console.WriteLine(++x) // x = 6

```

~

(1)

Bitwise complement

int x = ~127; // returns -128

```
>>

<<

```

(4)

Shift right

Shift left

```
byte x = 10; // binary 10 is 01010

int result = x << 1; // 20 = 10100

result = x >> 2;     //  5 = 00101

```

Works with byte, char, short, int, and long

```
&

|

^

```

(5-6-7)

Bitwise AND

Bitwise OR

Bitwise XOR

```
byte x = 12;        //    001100

byte y = 11;        //    001011

int result = x & y; //8 = 001000

result = x ^ y;     //7 = 000111

```

Core Note

C# does not provide an exponentiation operator. Instead, use the Math.Pow() method to raise a number to a power, and Math.Exp() to raise e to a power.

#### Conditional and Relational Operators

Relational operators are used to compare two values and determine their relationship. They are generally used in conjunction with conditional operators to form more complex decision constructs. Table 2-5 provides a summary of C# relational and conditional operators.

##### Table 2-5. Relational and Conditional Boolean Operators

Statement

Description

Example

```
==

!=

```

Equality

Inequality

if (x == y) {...}

```
<

<=

>

>=

```

Numeric less than

Less than or equal to

Greater than

Greater than or equal to

if (x <= y) {...}

```
&&

||

```

Logical AND

Logical OR

if (x == y && y < 30) {...}

If first expression is false, second is not evaluated

```
&

|

```

Logical AND

Logical OR

if (x== y | y < 30) {...}

Always evaluates second expression

!

Logical negation

if !(x ==y && y < 30) {...}

Note the two forms of the logical AND/OR operations. The && and || operators do not evaluate the second expression if the first is false梐 technique known as short circuit evaluation. The & and | operators always evaluate both expressions. They are used primarily when the expression values are returned from a method and you want to ensure that the methods are called.

In addition to the operators in Table 2-5, C# supports a ?: operator for conditionally assigning a value to a variable. As this example shows, it is basically shorthand for using an if-else statement:

```
string pass;

If(grade >= 70) pass="pass"; else pass="fail";

//     expression   ? op1  : op2

pass = (grade >= 70)  ? "pass" : "fail";

```

If the expression is TRue, the ?: operator returns the first value; if it's false, the second is returned.

#### Control Flow Statements

The C# language provides if and switch conditional constructs that should be quite familiar to C++ and Java programmers. Table 2-6 provides a summary of these statements.

##### Table 2-6. Control Flow Statements

Conditional Statement

Example

```
if (boolean expression) {

// statements

} else {

// statements

}

```

```
if (bmi < 24.9) {

weight = "normal";

riskFactor = 2;

} else {

weight = "over";

riskFactor=6;

}

```

```
switch (expression)

{

case constant expression:

// statements;

// break/goto/return()

case constant expression:

// statements;

// break/goto/return()

default:

// statements;

// break/goto/return()

}

```

• Constant expression may be an integer, enum value, or string.

• No "fall through" is permitted. Each case block must end with a statement that transfers control.

```
switch (ndx)

{

case 1:

fabric = "cotton";

blend = "100%";

break;

case 2:  // combine 2 & 3

case 3:

fabric = "cotton";

blend = "60%";

break;

default:  // optional

fabric = "cotton";

blend = "50%";

break;

}

```

#### if-else

Syntax:

```
if ( boolean expression ) statement

if ( boolean expression ) statement1 else statement2

```

C# if statements behave as they do in other languages. The only issue you may encounter is how to format the statements when nesting multiple if-else clauses.

```
// Nested if statements

if (age > 16)                         if (age > 16)

{                                        if (sex == "M")

if (sex == "M")                          type = "Man";

{                                     else

type = "Man";                         type = "Woman" ;

} else {                           else

type = "Woman" ;                   type = "child";

}

} else {

type = "child";

}

```

Both code segments are equivalent. The right-hand form takes advantage of the fact that curly braces are not required to surround single statements; and the subordinate if clause is regarded as a single statement, despite the fact that it takes several lines. The actual coding style selected is not as important as agreeing on a single style to be used.

#### switch

Syntax:

```
switch( expression ) {switch block}

```

The expression is one of the int types, a character, or a string. The switch block consists of case labels梐nd an optional default label梐ssociated with a constant expression that must implicitly convert to the same type as the expression. Here is an example using a string expression:

```
// switch with string expression

using System;

public class MyApp

{

static void Main(String[] args)

{

switch (args[0])

{

case "COTTON":   // is case sensitive

case "cotton":

Console.WriteLine("A good natural fiber.");

goto case "natural";

case "polyester":

Console.WriteLine("A no-iron synthetic fiber.");

break;

case "natural":

Console.WriteLine("A Natural Fiber. ");

break;

default:

Console.WriteLine("Fiber is unknown.");

break;

}

}

}

```

The most important things to observe in this example are as follows:

• C# does not permit execution to fall through one case block to the next. Each case block must end with a statement that transfers control. This will be a break, goto. or return statement.

• Multiple case labels may be associated with a single block of code.

• The switch statement is case sensitive; in the example, "Cotton" and "COTTON" represent two different values.