Introductory Programming Lecture Notes: types and conversions

Type compatability, conversions

Data types must match for each of the following situations:
- Each data type used by an operator must be of an appropriate type for that operator
- The data type of a variable on the LHS of an assignment statement must match the data type of the expression on the RHS
- When supplying values, variables, or expressions as parameters to a function, the data types supplied must match the data types of the function parameters (and in the correct order)
Some data types will automatically be converted for you, e.g.
```
   int x = 3;
   float y;
  
   y = x;
```
Before being assigned to y, a copy of the value of x is automatically converted from type int to type float

Sometimes you will want to deliberately convert one type of data to another.
This clearest syntax for this is (<type>)(<expression>)
e.g. to convert a floating point number to an integer: (int)(3.7) would produce 3
int to float basically just means appending .0000
float to int truncates (i.e. always drops fractions)
```
int left, total, dummy;
float number;

// the following is illegal (% must have an int on right)
left = total % number;

// but the following would work
left = total % (int)(number);
```
General note on conversions:
Conversions are described as either widening or narrowing:
- Widening conversions are conversions in which you convert elements of a subset into elements of a superset. For instance the integers are contained within the real numbers, so a conversion from int to float is a widening conversion.
  Widening conversions are commonly regarded as safe (within reasonable limits) and will be permitted in many languages and by many compilers.
- Narrowing conversions are conversions in which you convert elements from a larger set into elements of a subset. For instance, converting a float to an int would be a narrowing conversion.
  Narrowing conversions are widely regarded as unsafe (as there is a high possibility for loss of data). In C++ you can still perform many narrowing conversions, but typically a warning will be generated by the compiler if it detects such a conversion.

Less intuitively, you can also convert between integers and characters
The chart on page 63 of your text matches each character with an integer, e.g. 'W' = 87, 'X' = 88, 'Y' = 89, etc

Type conversions allow you to figure out in a program which character corresponds to which integer and vice versa

   int x, y;
   char a, b;
   x = int('T');   // x = 84
   y = x + 1;      // y = 85
   a = char(y);    // a = 'U'
   b = char(x);    // b = 'T'

As an aside, if you know the value for a lower case letter, e.g. 'a', the value for it's uppercase counterpart can be determined by adding 32
```
    printf("%c", char(32 + int('a')));
    // will print out A
```