Enumerated Types 4 Besides the built-in types, ANSI C allows the definition of user-defined...
-
date post
19-Dec-2015 -
Category
Documents
-
view
219 -
download
4
Transcript of Enumerated Types 4 Besides the built-in types, ANSI C allows the definition of user-defined...
Enumerated Types
Besides the built-in types, ANSI C allows the definition of user-defined enumerated types– To define a user-define type, you must give
(enumerate) each of the values which a variable of that type can have
typedef enum
{entertainment, rent, utilities, food, clothing, miscellaneous}
expense_t;
Enumerated Types
We can now use the type expense_t to declare variablesexpense_t expense_var;
– Then the value entertainment will be represented by a 0, rent by a 1, etc.
– We can assign values to a variable of this type as follows:
expense_var = entertainment;
– We can perform any operation on this variable that we can perform on an integer
Enumerated Types
Use enumerated types rather than integer codes to make your program more readable
Typedefs should be placed just after the precompiler directives (and before any variable declarations which use the type)
You cannot read in or print out enumerated types - only the integer equivalents
The order of enumeration defines the collation order of the type
Arrays
Simple variables use a single storage cell to store a single variable– If we want to store (for example) 5 values, we
have to declare 5 variables
– Sometimes we process a group of related data items (e.g. exam scores for a class)
– In this case, it is awkward to declare individual variables for each value so we use a data structure called an array to hold all of the values
Arrays
An array is a collection of two or more adjacent memory cells called array elements
We can declare an array with a single variable declaration, e.g. double x[8]; declares an array of eight doubles– The array has a single name– To refer to individual elements of the array we
use the array name with an array subscript
Arrays
x[5] = 77.0; printf(“%f\n”, x[5]); This example refers to the fifth value of the array x
Note that the first value in array x is x[0] - that is, array subscripts start with 0
What is the last element of array x then? Generally, we will always refer to individual
elements of the array (i.e. we will always use subscripts with the array name)
Arrays
The declaration of an array of a given type is the same as the declaration of a simple variable of that type except that we follow the name of the array with [size] where size is the size of the array– Note that we don’t specify upper and lower bounds
for the array, just the size
Parallel arrays store related information in corresponding fields of two separate arrays
Array Initialization
A simple variable can be initialized when it is declared:int int_var = 0;– An array can also be initialized when it is declared
int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
– Note that we don’t need to give the size of the array if we initialize it in the declaration (otherwise, we do)
Array Subscripts
A subscript can be an integer literal, a constant given in a #define, or any expression which evaluates to an integer value– The expression must evaluate to a value in the
range of 0 to size of array - 1, otherwise a run-time error will occur
– The expression cannot evaluate to a floating point number
Examples
i = 5; x[0]=16.0; x[1]=12.0; x[2]=6.0; x[3]=8.0; x[4]=2.5; x[5]=12.0; x[6]=14.0; x[7]=-54.5;
printf(“%d %.1f“, 4, x[4]);
printf(“%d %.1f“, i, x[i]);
printf(“%.1f“, x[i] + 1);
printf(“%.1f“, x[i] + i);
printf(“%.1f“, x[i + 1]);
printf(“%.1f“, x[i + i]);
printf(“%.1f“, x[2 * i]);
Examples
printf(“.1f“, x[2 * i - 3]);
printf(“.1f“, x[(int)x[4]]);
printf(“.1f“, x[i++]);
printf(“.1f“, x[--i]);
x[i-1] = x[i];
x[i] = x[i+1];
x[i] - 1 = x[i];
Using for Loops with Arrays
Since the elements of an array are related, we often want to perform the same processing on each element of the array
We can do this by using a for loop to step through the array, element-by-element– The loop variable is initialized to the lower bound
of the array– The condition is to exit when the upper bound is
reached
Using for Loops with Arrays
– The loop variable is used as the subscript of the array in the loop body
for (i = 0; i < SIZE; ++i)
square[i] = i * i;
for (j = 0; j < SIZE; j++)
printf(“The score for %d is %d\n”,
j, score[j]);
for (k = 0; k < MAX_ITEM; ++k)
scanf(“%lf”, &x[k]);
Using for Loops with Arrays
#include <stdio.h>
#include <math.h>
#define MAX_ITEM 8
int main(void) {
double x[MAX_ITEM], mean, st_dev, sum, sum_sqr;
int i;
printf(“Enter %d numbers separated by blanks “
“or <return>s\n”, MAX_ITEM);
for (i = 0; i < MAX_ITEM; ++i)
scanf(“%lf”, &x[i]);
sum = 0; sum_sqr = 0;
Using for Loops with Arrays
for (i = 0; i < MAX_ITEM; ++i) {
sum += x[i];
sum_sqr += x[i] * x[i];
}
mean = sum / MAX_ITEM;
st_dev = sqrt(sum_sqr / MAX_ITEM - mean*mean);
prinf(“The mean is %.2f.\n”, mean);
printf(“Standard deviation is %.2f.,st_dev);
printf(“\nTable of differences\n); printf(“IndexItem Difference\n”);
for (i = 0; i < MAX_ITEM; ++i)
printf(“%3d%4c%9.2f%5c%9.2F\n”,i,’ ‘,x[i],
‘ ‘,x[i]-mean);
return(0); }
Using Array Elements as Function Arguments Individual array elements can be used as
actual array arguments– printf(“%d\n”,x[i]);– scanf(“%d %d”, &x[0], &x[1]);
The array of the element which we are passing must be of the same type as the formal argument of the function– Note that an array element can be used as either an
input argument - x[i] - or an output argument - &x[0]
Array Arguments
We can also write functions that have arrays as arguments (i.e. that manipulate all or part of an array)
We can declare an array function as an argument with no subscript– int list[]– This declaration allows us to use the array as an
output parameter or input/output parameter (but not input only)
Array Arguments
An important point is that in the argument declaration we don’t indicate the size of the array– If we want to do this, we must use another argument
for this purpose– int list[], int size_of_list
C does not allocate memory for a local copy of the array, instead it passes the address of the first element of the array
Array Arguments
Given a formal argument for an array of the type shown previously, we can call the function by using the name of the array as the actual argument in the function call:func_name(my_array, ARRAY_SIZE);
– We don’t use a subscript in the function call– The actual argument is just the first element of the array,
so we could also use:func_name(&my_array[0], ARRAY_SIZE);
– The first version is preferred
Array Arguments
In the formal parameter list, instead of int list[], we could also int *list– This is because C passes the address of the first
element of the array
– You probably won’t use this form until we start to work with strings
ANSI C we can include a qualifier in the declaration of the array formal parameter to notify the compiler that the array is input only - void my_func(const int my_array[]);
Array Arguments
In C, it is not legal for a function’s return type to be an array– We must therefore use an output argument to
return the array – The calling function must supply an array for
the output results (i.e. the calling function must declare an array of the desired size and pass the address of the array, but it need not initialize the array)
Array Arguments
It is often the case that we don’t know exactly how many data items we must process in a program– Suppose we are processing these data items in an
array– We can declare the array to be as large as the
largest data set we will have to process and then just use a part of the array if the data set is smaller than that