CSC270 Sept 30 Tutorial: More C


Conversion between types of variables

[King 7.5] What happens when you assign a float to an int? int i; float x; x = 3.14; i = x; C converts the float into an int before assigning it. Typically, C will truncate any fractional part of the float. Numeric operators must have arguments of the same type. If we add an int and a float, the int gets `promoted' to a float before the addition takes place. y = i + x; Watch out for divisions with integers! If you divide integer i by integer j and *then* assign the result to a float x, the value i/j will be an integer which is converted to a float *upon* being assigned. This means that the fractions part of the quotient will be lost: int i, j; float x; i = 7; j = 2; x = i/j; printf( "%g\n", x ); --> 3 You must explicitly convert one of the ints to a float *before* doing the division. If one argument of the division is a float, the other will be automatically converted to a float and the quotient will be a float. To convert a variable to a new type, add the type name in parentheses in from of the variable: x = i / (float) j; printf( "%g\n", x ); --> 3.5 The explicit transformation into a new type is called a `cast'. A variable (or expression) is said to be `cast' into a new type.

Arrays

[King 8] An array hold many elements of the same type. Each element is associated with an index. In C, indices always start with *zero*. To declare an array of 10 integers or floats or chars: int i[10]; float f[10]; float c[10]; The array can be thought of as i +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+ | | | | | | | | | | | +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+ i[0] i[1] i[2] i[3] i[4] i[5] i[6] i[7] i[8] i[9] The variable `i' denotes the *whole* array, whereas `i[k]' denotes element k of the array. This is often pronounced ``i at k''. `k' is called the index. The index can be any integer expression. To initialize an array: #define N 10 int a[ N ]; for (i=0; i < N; i++) a[i] = 0; To compute Fibonacci numbers (recall f(i) = f(i-1) + f(i-2)): a[0] = 1; a[1] = 1; for (i=2; i < N; i++) a[i] = a[i-1] + a[i-2]; Note that the array indices go from 0 to N-1, *not* from 1 to N!

The `switch' statement

[King 5.3] Sometimes, we want to do many different things based upon the many possible values of an expression. The `switch' statement does this: switch (expr) { case value1: ... case value2: ... case value3: ... default: ... } 1. The `expr' is evaluated *once* and its value is compared with each of the case values (value1, value2, value3, ... above) in turn, starting from the top. 2. When the first value that matches the expression is found, the statments under that case (... above) are executed. 3. If no case value is found, the statements after `default' are executed. The `default' case doesn't have to be present. The statements (... above) almost always end with a `break' statement: switch ( transaction_type ) { case 1: printf( "Deposit\n" ); break; case 2: printf( "Withdrawl\n" ); break; case 3: printf( "Transfer\n" ); break; case 4: printf( "Bill payment\n" ); break; default: printf( "Unrecognized transaction type: %d\n", transaction_type ); } If the `break' is left out, the program will continue executing the statements in the rest of the switch. For example, if all the `break's were left out of the code and the transaction_type was 3, the output would be switch ( transaction_type ) { case 1: printf( "Deposit\n" ); case 2: printf( "Withdrawl\n" ); case 3: printf( "Transfer\n" ); case 4: printf( "Bill payment\n" ); default: printf( "Unrecognized transaction type: %d\n", transaction_type ); } --> Transfer Bill payment Unrecognized transaction type: 3