Functions in C. Lecture Topics. Lecture materials. Homework. Machine problem. Announcements. ECE 190 Lecture 16 March 9, 2011

Transcription

1 Functions in C Lecture Topics Introduction to using functions in C Syntax Examples Memory allocation for variables Lecture materials Textbook , 12.5 Homework Machine problem MP3.2 due March 18, 2011 at 5pm submitted electronically. Announcements Exams next week 1 V. Kindratenko

2 Introduction to functions in C A function in C is roughly equivalent to a subroutine in LC-3 assembly language It is a segment of code that implements some well-defined function in the program Example from MP3 o Clear board o Setup board o Display board All these are functions that do some well-defined work. The main program then just calls them when needed Using functions enables o Hiding low-level details o Giving high-level structure to the program o Efficiently reusing code Syntax Using functions in C requires: 1. A function prototype, or function s declaration o Note we did not need one in LC-3 assembly language o Example: int Factorial(int n); o Function prototype specifies three things: Name of the dunction, e.g., sin, cons, printf, Factorial, etc. Types of all arguments that are passed to the function, e.g., int for n in the example above Type of return value o Examples: double cos(double x); <- cos function requires one argument of type double and returns a value of type double int getchar(void); <- reads a character form keyboard and returns its ascii value; does not require any arguments = no input. void clearscreen(void); <- clears screen, takes no arguments, returns nothing. o A function may return no value; in this case its return type is void o A function may not require any arguments; in this case its arguments list is declared as void o Function prototype must be provided before the function is called in the program 2. Function definition or implementation o Note we needed this in LC-3 assembly as well o This is the actual source code of the function o It includes a formal list of arguments a list of variables declared and the order in which they are exposed to the user o Example 2 V. Kindratenko

3 int Factorial(int n) int i, result=1; for (i = 0; i <= n; i++) result = result * i; o o return result; In this example, we have an implementation of the function to compute factorial of number n. Value of n is passed to the function as an argument. Result is returned back to the calling program using return keyword. To use this function, we need to just call it from our main function: #include <stdio.h> /* our Factorial function prototype goes here */ int Factorial(int n); /* main function */ int main() int number; int answer; printf( Enter a number: ); scanf( %d, &number); answer = Factorial(number); /* number is the argument that is transmitted from the calling function (main) to the called function */ printf( factorial of %d is %d\n, number, answer); return 0; /* implementation of Factorial function goes here */ More examples MP1.2 example: convert the computation of sin function into an actual function. Before: 3 V. Kindratenko

4 #include <stdio.h> #define PI int main() double x = 0.0; double sin_x = 0.0; double r = 0.0; double sin_x_num; double sin_x_den; double error; int n; /* get x (in degrees) and r from the user */ printf("enter x (in degrees): "); scanf("%lf", &x); printf("enter the maximum error: "); scanf("%lf", &r); /* correct the domain of x */ while (x < -180 x > 180) x = (x > 180)? x : x + 360; /* converts degrees to radians */ x *= PI/180; /* compute the sine of x */ n = 1; sin_x_num = x; sin_x_den = 1; sin_x = sin_x_num/sin_x_den; error = ((sin_x_num*x*x)/(sin_x_den*(n+2)*(n + 1))); /* repeat previous computation if error does not equal r */ while (error > r error < (-1 * r)) n += 2; sin_x_num *= (-1) * (x * x); sin_x_den *= n * (n - 1); sin_x += sin_x_num / sin_x_den; error = ((sin_x_num*x*x)/(sin_x_den*(n+2)*(n+1))); /* print results to the terminal */ printf("sin(%lf) = %lf\n", x, sin_x); return 0; After: 4 V. Kindratenko

5 #include <stdio.h> #define PI double mysin(double x, double r); /* function prototype */ int main() double x = 0.0; double sin_x = 0.0; double r = 0.0; /* get x (in degrees) and r from the user */ printf("enter x (in degrees): "); scanf("%lf", &x); printf("enter the maximum error: "); scanf("%lf", &r); /* correct the domain of x */ while (x < -180 x > 180) x = (x > 180)? x : x + 360; /* converts degrees to radians */ x *= PI/180; sin_x = mysin(x, r); /* call to our function */ /* print results to the terminal */ printf("sin(%lf) = %lf\n", x, sin_x); return 0; double mysin(double x, double r) /* function implementation */ double sin_x_num; double sin_x_den; double error; int n; /* compute the sine of x */ n = 1; sin_x_num = x; sin_x_den = 1; sin_x = sin_x_num/sin_x_den; error = ((sin_x_num*x*x)/(sin_x_den*(n+2)*(n + 1))); /* repeat previous computation if error does not equal r */ while (error > r error < (-1 * r)) n += 2; 5 V. Kindratenko

6 sin_x_num *= (-1) * (x * x); sin_x_den *= n * (n - 1); sin_x += sin_x_num / sin_x_den; error = ((sin_x_num*x*x)/(sin_x_den*(n+2)*(n+1))); return sin_x; Memory allocation for variables When a C compiler compiles a program, it keeps track of variables in a program using a symbol table. Whenever it finds a new variable declaration, it creates a new entry in its symbol table corresponding to the variable being declared. Symbol table contains enough information for the compiler to allocate storage in memory for the variable and for the generation of the proper sequence of machine code to access the value of that variable when it is used in the program. Each entry in the symbol table has 4 items: o Name of the variable o Its type o Place in memory the variable has been allocated storage o Identifier for the block in which the variable is declared Example for our MP4.2 program with the function: Variable identifier (name) type Location (as an offset) Scope x double 0 main sin_x double -1 main r double -2 main sin_x_num double 0 mysin sin_x_den double -1 mysin error double -2 mysin n int -3 mysin o 7 variables total o Variable s location in memory is recorded as an offset which indicates relative position of the variable within the region of memory it is allocated. This indicates how many locations from the base of the section a variable is allocated storage. There are two regions of memory in which C variables are allocated storage space: o Global data section Where all global variables are stored Or more generally where variables of the static storage class are allocated o Run-time stack Where local variables (of the default automatic storage class) are allocated We will talk about it in the next lecture 6 V. Kindratenko

7 Memory map for a C program x3000 System space Program text PC Global data section Heap (for dynamically allocated memory) R4 Variables of static storage class are stored in the global data section Run-time stack contains activation records (or stack frames) for called functions Run-time stack System space R6 (stack pointer) R5 (frame pointer) Variables of the default automatic storage class are stored in the run-time stack space Note use of registers R4, R5, and R6 o R4 points to the first address of memory allocated for global variables o R5 contains stack pointer memory region inside the function s activation record where local variables are stored o R6 contains address of the top of the run-time stack When we call a function in C, its activation record is pushed onto the run-time stack Whenever a function completes, its activation record is popped off the run-time stack Function s activation record contains all the data local to the function involved in the function invocation, execution, and transfer of the results back to the calling function o Its exact structure depends on the compiler implementation; we will study just one particular example implementation 7 V. Kindratenko