The Assignment statement

The main statement in C++ for carrying out computation and assigning
values to variables is the **assignment statement**. For example
the following assignment statement:

```
````average = (a + b)/2;`

assigns half the sum of `a`

and `b`

to the variable
`average`

. The general form of an assignment statement is:
Theresult`=`

expression`;`

The *expression* can be a single variable, a single constant or
involve variables and constants combined by the arithmetic operators
listed below. Rounded brackets `()`

may also be used in matched
pairs in expressions to indicate the order of evaluation.

For example`+`

addition

`-`

subtraction

`*`

multiplication

`/`

division

`%`

remainder after division (modulus)

i = 3; sum = 0.0; perimeter = 2.0 * (length + breadth); ratio = (a + b)/(c + d);

The type of the operands of an arithmetic operator is important. The following rules apply:

- if both operands are of type
**int**then the result is of type**int**. - if either operand, or both, are of type
**float**then the result is of type**float**. - if the expression evaluates to type
**int**and the result variable is of type**float**then the`int`

will be converted to an equivalent`float`

before assignment to the result variable. - if the expression evaluates to type
**float**and the result variable is of type**int**then the`float`

will be converted to an`int`

, usually by rounding towards zero, before assignment to the result variable.

The last rule means that it is quite easy to lose accuracy in an
assignment statement. As already noted the type of the value assigned
must be the same type as the variable to which it is assigned. Hence
in the following example in which `i`

is a variable of type
`int`

```
````i = 3.5;`

the compiler will insert code to convert the value 3.5 to an integer
before carrying out the assignment. Hence the value 3 will be
assigned to the variable `i`

. The compiler will normally
truncate float values to the integer value which is nearer to
zero. Rounding to the nearest integer is A similar problem arises with the division operator. Consider the following rule:

- the result of a division operator between two
**int**operands is of type**int**. It gives the result truncated towards zero if the result is positive, the language does not define what should happen if the result is negative, so beware! This of course means that it is very easy to lose accuracy if great care is not taken when using division with integer variables.

```
````i = 1/7;`

will assign the value zero to the integer variable `i`

. Note
that if the quotient of two integers is assigned to a float then the
same loss of accuracy still occurs. Even if `i`

in the above
assignment was a variable of type `float`

`1/7`

would still
be evaluated as an integer divided by an integer giving zero, which
would then be converted to the equivalent `float`

value,
i.e. 0.0, before being assigned to the `float`

variable
`i`

.
The modulus operator `%`

between two positive integer variables
gives the remainder when the first is divided by the second. Thus
`34 % 10`

gives 4 as the result. However if either operand is
negative then there are ambiguities since it is not well-defined in
C++ what should happen in this case. For example `10 % -7 `

could be interpreted as 3 or -4. Hence it is best to avoid this
situation. All that C++ guarantees is that

i % j = i - (i / j) * j

- Priority of Operators
- Examples of Arithmetic Expressions
- Type Conversions
- Example Program: Temperature Conversion
- Example Program: Pence to Pounds and Pence
- Summary
- Multiple Choice Questions
- Review questions
- Exercises

1999-08-31