Assignment Operators (=, +=, -=, *=, /=, %=,<<=, >>=, &=, ^=, |=)

Unlike arithmetic conversions, which always expand the expression, assignment conversions can truncate the expression and therefore affect its value. For example, suppose c is a char, and you make the following assignment:

c = 882;

The binary representation of 882 is

00000011 01110010

This number requires two bytes of storage, but the variable c has only one byte allocated for it, so the two upper bits don't get assigned to c. This is known as overflow, and the result is not defined by the ANSI/ISO C standard or the K&R language definition for signed types. HP C simply ignores the extra byte, so c would be assigned the rightmost byte:

01110010

This would erroneously give c the value of 114. The principle illustrated for chars also applies to shorts, ints, and long ints. For unsigned types, however, C has well-defined rules for dealing with overflow conditions. When an integer value x is converted to a smaller unsigned integer type, the result is the non-negative remainder of

x / (U_MAX+1)

where U_MAX is the largest number that can be represented in the shorter unsigned type. For example, if j is an unsigned short, which is two bytes, then the assignment

j = 71124;

assigns to j the remainder of

71124 / (65535+1)

The remainder is 5588. For non-negative numbers, and for negative numbers represented in two's complement notation, this is the same result that you would obtain by ignoring the extra bytes.

You may assign an integer value to a floating-point variable. In this case, the integer value is implicitly converted to a floating-point type. If the floating-point type is capable of representing the integer, there is no change in value. If f is a double, the assignment

f = 10;

is executed as if it had been written

f = 10.0;

This conversion is invisible. There are cases, however, where a floating-point type is not capable of exactly representing all integer values. Even though the range of floating-point values is generally greater than the range of integer values, the precision may not be as good for large numbers. In these instances, conversion of an integer to a floating-point value may result in a loss of precision. Consider the following example:

#include <stdio.h>
int main(void)
{
long int j = 2147483600;
float x;
x = j;
printf("j is %d\nx is %10f\n", j, x);
exit(0);
}

If you compile and execute this program, you get:

j is 2147483600
x is 2147483648.000000

The most risky mixture of integer and floating-point values is the case where a floating-point value is assigned to an integer variable. First, the fractional part is discarded. Then, if the resulting integer can fit in the integer variable, the assignment is made. In the following statement, assuming j is an int, the double value 2.5 is converted to the int value 2 before it is assigned.

j = 2.5;

This causes a loss of precision which could have a dramatic impact on your program. The same truncation process occurs for negative values. After the assignment

j = -5.8;

the value of j is -5.

An equally serious situation occurs when the floating-point value cannot fit into an integer. For example:

j = 999999999999.0

This causes an overflow condition which will produce unpredictable results. As a general rule, it is a good idea to keep floating-point and integer values separate unless you have a good reason for mixing them.

As is the case with assigning floating-point values to integer variables, there are also potential problems when assigning double values to float variables. There are two potential problems: loss of precision and an overflow condition. In HP C a double can represent approximately 16 decimal places, and a float can only represent 7 decimal places. If f is a float variable, and you make the assignment

f = 1.0123456789

the computer rounds the double constant value before assigning it to f. The value actually assigned to f, therefore, will be 1.012346 (in double-to-float conversions, HP C always rounds to the nearest float value). The following example shows rounding due to conversions.

/* Program name is "float_rounding". It shows how double values
can be rounded when they are assigned to a float. */
#include <stdio.h>
int main(void)
{
float f32;
double f64;
int i;
for (i = 1, f64 = 0; i < 1000; ++i)
f64 += 1.0/i;
f32 = f64;
printf("Value of f64: %1.7f\n", f64);
printf("Value of f32: %1.7f\n", f32);
}

The output is

Value of f64: 7.4844709
Value of f32: 7.4844708

A serious problem occurs when the value being assigned is too large to be represented in the variable. For example, the largest positive number that can be represented by a float is approximately 3e38. However, neither the K&R language definition nor the ANSI/ISO C standard defines what happens if you try to make an assignment outside this range. Suppose, for example, that your program contains the following assignment:

f = 2e40;

In this simple case, the compiler recognizes the problem and reports a compile-time error. In other instances, however, a run-time error could result.