Using Arithmetic Operators

C# supports the regular arithmetic operations you learned in your childhood: the plus sign (+) for addition, the minus sign (–) for subtraction, the asterisk (*) for multiplication, and the forward slash (/) for division. These symbols (+, –, *, and /) are called operators as they “operate” on values to create new values. In the following example, the variable moneyPaidToConsultant ends up holding the product of 750 (the daily rate) and 20 (the number of days the consultant was employed):

long moneyPaidToConsultant; moneyPaidToConsultant = 750 * 20;

The values that an operator operates on are called operands. In the expression 750 * 20, the * is the operator, and 750 and 20 are the operands.

Determining an Operator's Values

Not all operators are applicable to all data types, so whether you can use an operator on a value depends on the value's type. For example, you can use all the arithmetic operators on values of type char, int, long, float, double, or decimal. However, with one exception, you can't use the arithmetic operators on values of type string or bool. So the following statement is not allowed because the string type does not support the minus operator (subtracting one string from another would be meaningless):

// compile time error Console.WriteLine("Gillingham" – "Manchester City");

The exception is that the + operator can be used to concatenate string values. The following statement writes 431 (not 44) to the console:

Console.WriteLine("43" + "1");

You can use the method Int32.Parse to convert a string value to an integer if you need to perform arithmetic computations on values held as strings.

You should also be aware that the type of the result of an arithmetic operation depends on the type of the operands used. For example, the value of the expression 5.0 / 2.0 is 2.5; the type of both operands is double (in C#, literal numbers with decimal points are always double, not float, in order to maintain as much accuracy as possible), and so the type of the result is also double. However, the value of the expression 5 / 2 is 2. In this case, the type of both operands is int, and so the type of the result is also int. C# always rounds values down in circumstances like this. The situation gets a little more complicated if you mix the types of the operands. For example, the expression 5 / 2.0 consists of an int and a double. The C# compiler detects the mismatch and generates code that converts the int into a double before performing the operation. The result of the operation is therefore a double (2.5). However, although this works, it is considered poor practice to mix types in this way.

C# also supports one less-familiar arithmetic operator: the remainder, or modulus, operator, which is represented by the percent symbol (%). The result of x % y is the remainder after dividing x by y. For example, 9 % 2 is 1 since 9 divided by 2 is 8, remainder 1.

In C and C++, you can't use the % operator on floating-point values, but you can use it in C#.

Examining Arithmetic Operators

The following exercise demonstrates how to use the arithmetic operators on int values using a previously written C# program named MathsOperators.

Work with arithmetic operators

On the File menu, point to Open, and then click Project/Solution. Open the MathsOperators project, located in the \Microsoft Press\Visual CSharp Step by Step\Chapter 2\MathsOperators folder in your My Documents folder.

On the Debug menu, click Start Without Debugging.

A form appears on the screen.

Type 54 in the left operand text box.

Type 13 in the right operand text box.

You can now apply any of the operators to the values in the text boxes.

Click the – Subtraction option, and then click Calculate.

The text in the Expression box changes to 54 – 13, and 41 appears in the Result box, as shown in the following graphic:

Click the / Division option, and then click Calculate.

The text in the Expression text box changes to 54 / 13, and the number 4 appears in the Result box. In real life, 54 / 13 is 4.153846 recurring, but this is not real life; this is C#! In C#, when you divide one integer by another integer, the answer you get back is an integer, as explained earlier.

Select the % Remainder option, and then click Calculate.

The text in the Expression text box changes to 54 % 13, and the number 2 appears in the Result box. This is because the remainder after dividing 54 by 13 is 2 (54 – ((54 / 13) * 13) is 2 if you do the arithmetic rounding down to an integer at each stage—my old maths master at school would be horrified to be told that (54 / 13) * 13 does not equal 54!).

Practice with other combinations of numbers and operators. When you're finished, click Quit.

The program stops, and you return to the Visual Studio 2005 programming environment.

Now take a look at the MathsOperators program code.

Examine the MathsOperators program code

Display the Form1 form in the Design View window (click the Form1.cs[Design] tab if necessary).

**TIP**

You can quickly switch between the Design View window and the Code and Text Editor displaying the code for a form by pressing the F7 key.In the View menu, point to Other Windows and then click Document Outline.

The Document Outline window appears showing the names and types of the controls on the form. If you click each of the controls on the form, the name of the control is highlighted in the Document Outline window.

**IMPORTANT**

Be careful not to accidentally delete or change the names of any controls on the form while viewing them in the Document Outline window. The application will no longer work if you do.Click the the two TextBox controls that the user types numbers into on the form. In the Document Outline window, verify that they are named lhsOperand and rhsOperand.

When the form runs, the Text property of each of these controls holds (as strings) the numeric values you enter.

Towards the bottom of the form, verify that the TextBox control used to display the expression being evaluated is named expression, and that the TextBox control used to display the result of the calculation is named result.

At runtime, setting the Text property of a TextBox control to a string value causes that value to be displayed.

Close the Document Outline window.

Press F7 to display the Form1.cs source file in the Code and Text Editor window.

In the Code and Text Editor window, locate the subtractValues method:

private void subtractValues() { int lhs = int.Parse(lhsOperand.Text); int rhs = int.Parse(rhsOperand.Text); int outcome; outcome = lhs – rhs; expression.Text = lhsOperand.Text + " – " + rhsOperand.Text; result.Text = outcome.ToString(); }

The first statement in this method declares an int variable called lhs and initializes it to the result of the explicit conversion of the lhsOperand.Text property to an int. (The Text property of a TextBox is a string, and must be converted to an integer before you can store it in an int. This is what the int.Parse method does) The second statement declares an int variable called rhs and initializes it to the result of the explicit conversion of the rhsOperand.Text property to an int. The third statement declares an int variable called outcome. The fourth statement subtracts the value of the rhs variable from the value of the lhs variable, and the result is assigned to outcome. The fifth statement concatenates three strings (using the + operator) and assigns the result to the expression.Text property. The sixth statement converts the int value of outcome to a string by using the ToString method, and assigns the string to the result.Text property.

Controlling Precedence

Precedence governs the order in which an expression's operators are evaluated. Consider the following expression, which uses the + and * operators:

2 + 3 * 4

This expression is potentially ambiguous; does 3 bind to the + operator on its left or to the * operator on its right? The order of the operations matters because it changes the result:

If the + operator takes precedence over the * operator, 3 binds to the + operator, the result of the addition (2 + 3) forms the left operand of the * operator, and the result of the whole expression is 5 * 4, which is 20.

If the * operator takes precedence over the + operator, 3 binds to the * operator, the result of the multiplication (3 * 4) forms the right operand of the + operator, and the result of the whole expression is 2 + 12, which is 14.

In C#, the multiplicative operators (*, /, and %) have precedence over the additive operators (+ and –). The answer to 2 + 3 * 4 is therefore 14. As each new operator is discussed in later chapters, its precedence will be explained.

You can use parentheses to override precedence and force operands to bind to operators in a different way. For example, in the following expression, the parentheses force the 2 and the 3 to bind to the + operator (making 5), and the result of this addition forms the left operand of the * operator to produce the value 20:

(2 + 3) * 4

The term parentheses or round brackets refers to ( ). The term braces or curly brackets refers to { }. The term square brackets refers to [ ].

Using Associativity to Evaluate Expressions

Operator precedence is only half the story. What happens when an expression contains different operators that have the same precedence? This is where associativity becomes important. Associativity is the direction (left or right) to which an expression's operators are bound. Consider the following expression that uses the / and the * operators:

4 / 2 * 6

This expression is still potentially ambiguous. Does 2 bind to the / operator to its left or to the * operator to its right? The precedence of both operators is the same (they are both multiplicative), but the order in which the expression is evaluated is important because you get one of two possible results:

If the 2 binds to the / operator, the result of the division (4 / 2) forms the left hand operand of the * operator, and the result of the whole expression is (4 / 2) * 6, or 12.

If the 2 binds to the * operator, the result of the multiplication (2 * 6) forms the right hand operand of the / operator and the result of the whole expression is 4 / (2 * 6), or 4/12.

Because the * and / operators have the same precedence, you cannot use precedence to determine whether the 2 binds to the * operator or to the / operator. However, operators also have associativity to determine how they are evaluated. The * and / operators are both left-associative, which means that the operands are evaluated from left to right. In this case, 4 / 2 will be evaluated before multiplying by 6, giving the result 12. As each new operator is discussed in later chapters, its associativity will also be covered.