Sign In Sign-Up

Welcome!

Close

Would you like to make this site your homepage? It's fast and easy...

Yes, Please make this my home page!

No Thanks

  Don't show this to me again.

Close

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:

result = expression ;

The expression is evaluated and then the value is assigned to the variable result. It is important to note that the value assigned to result must be of the same type as result.

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.

+ addition
- subtraction
* multiplication
/ division
% remainder after division (modulus)

For example

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 not carried out.

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.

For example the statement

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