## Arithmetic Expressions

You need to know the definition of an arithmetic expression and the precedence of the operators.

### Arithmetic Expressions

Variables and constants of integral and floating point types can be combined into expressions using arithmetic operators. The arithmetic operators are listed in the following table:
```    Operators		Description

+		Unary plus needs one operand.

-		Unary minus needs one operand.

-		Subtraction needs two operands.

*		Multiplication needs two operands.

/		Division needs two operands.
(
Floating point operands:
-- floating point result
Integer operands:
-- integer quotient
Mixed operands:
-- floating point result
)

%		Modulus
(
remainder from integer division
operands must be integeral
)

++		Increment by one;
can be prefix or postfix;
as postfix has highest precedence

--		Decrement by one;
can be prefix or postfix;
as postfix has highest precedence

```

### Precedence of Arithmetic Operations

The precedence rules of arithmetic apply to arithmetic expressions in a program. That is, the order of execution of an expression that contains more than one operation is determined by the precedence rules of arithmetic. These rules state that parentheses have the highest precedence, multiplication, division, and modulus have the next highest precedence, and addition and subtraction have the lowest. The Postfix increment and decrement operators have the highest precedence over any of the arithmetic operators.

Look at the following example, and decide what is written by each of the output statements.

```/*************************************************************
*
*   The program demonstrates the precedence of the operators.
*
*************************************************************/

#include <iostream>
using namespace std;

int main ()
{
cout << 4 + 3 * 5  << endl;
cout << (4 + 3) * 5  << endl;
cout << 4 * 5 % 3 + 2  << endl;
cout << (4 * (5 % 3) + 2)  << endl;
return 0;
}
```
Click on the box below to see the answers:
19
35
4
10

You can run the program to verify the results.

### Converting Numeric Types

If an integral and a floating point variable or constant are mixed in an operation, the integral value is changed temporarily to its equivalent floating point representation before the operation is executed. This automatic conversion of an integral value to a floating point value is called type coercion. Type coercion also occurs when a floating point value is assigned to an integral variable. Coercion from an integer to a floating point is exact. However, when a floating point value is coerced into an integral value, the fractional part is truncated.

Type changes can be made explicit by placing the value to be changed in parentheses and placing the name of the new type before it. This is called type casting or type conversion. For example,

```	intValue = 10.66;	and
intValue = int(10.66) 	produce the same result 10.
```
In summary, we have explicit and implicit data type conversion.
```Type coercion	The implicit (automatic) conversion of
a value from one data type to another.

Type casting	The explicit  conversion of a value from
one data type to another;
also called type conversion.
```

Copyright: Department of Computer Science, University of Regina.