C functions. Rolling your own

Transcription

1 C functions Rolling your own

2 Why functions? Encourage modular development Concentrate on one problem at a time Reusable code Write code once, use many times Can improve readability of code

3 Function Named set of instructions Can be called multiple times Whenever needed Won't come unless it's called (unless it's main) 3 types of statements to know about Function calls Function definitions Function prototypes

4 Function definition The definition of a function consists of its heading and a body of code containing the instructions that should execute when the function is called Syntax: Heading { } /* set of instructions */

5 Function heading The heading of a C function provides the basic information a programmer needs to make a syntactically correct call to the function; that is: The return type (what, if any, type of value does a call to this function represent?) The name The parameter list (the data type(s) & order of arguments to be passed to the function

6 Function heading Syntax: Data type name (parameter(s)) Where: Data type is an existing C type (int, double, char) or void, meaning no type Name is a valid C identifier Parameters are declaration(s) for variable(s) that will hold the value(s) of any argument(s) passed to the function If parameter list is empty, then the function doesn't take arguments Multiple parameters are separated by commas

7 Function body The body of the function consists of the set of instructions enclosed within curly brackets ({}) immediately following the function heading The set of instructions operates on the data available to it; this includes: Parameter values Variables declared within the function body itself Global variables (use with caution!)

8 Example

9 Function return statements If the function heading indicates a return type other than void, then a return statement is required Returns an expression that is the type of value indicated in the heading Ends function operation, so program resumes where it left off (immediately after function call) Usually the last statement in a function A function can return either one value (matching the return type) or no value (return type void) Can include a return statement in a void method, if desired; syntax: return;

10 What the function does & doesn't Does: Calculate force based on given values for mass & acceleration Return the result for use elsewhere in the program Doesn't: Do any input or output Concern itself with where the values for its parameters came from; they are given

11 Why no I/O? Functions are intended to be generally useful Do one job & do it well Not tied to any particular application Including user interaction within a function actually limits its usefulness Restricts use of function to interactive programs (read from keyboard, not from file, e.g.) Messages to users tend to be specific to application; any output from function typically tied to that application

12 Function prototypes In a C program, every identifier must be declared before it can be used; for example: x = 19; Can't be placed in the program before int x; Similarly, a function can't be called before its name is known We could just write function definitions before any calls, but this can become impossible. Consider the following example...

13 Call example Function A calls Function B Function B calls Function C Function C calls Function A What order should we define them in? Function prototypes exist to resolve situations like this

14 Function prototypes A function prototype is a declaration for a function Contains the same information as a function heading Serves as sort of an indication of intention; the compiler can resolve a function call if it's seen the prototype, even if the definition is physically below the call (or even in another file)

15 Scope of identifiers Once something has been declared, it can be used in a function, as long as its scope can be resolved scope refers to the part of a program in which an identifier has meaning The more local the declaration of an identifier, the narrower its scope Important note: identifier means any name in a program could be the name of a variable, constant, or function (among other things)

16 Scope of identifiers Anything declared outside the boundaries of a method has global scope Identifier is meaningful from its point of declaration until the end of the file Best practice: reserve global scope for function names and named constants Anything declared within a block of code is local to that block

17 Scope examples

18 Scope complications Two identifiers in the same program have the same name; which one is being referred to in a particular instruction? The answer depends on two things: Where the identifiers were declared Where the referring instruction occurs

19 Scope clash Two variables with the same name in the same scope cause a scope clash syntax error Example: void badmethod (int x) { } int x = x + 3; /* scope clash! */ Since parameter x and local variable x are in the same scope, the compiler can't resolve the expression

20 Not a scope clash #include <stdio.h> #include <stdlib.h> #include <time.h. int times10(int x); int main() { srand(time(null)); int x, y; x = rand() % ; printf("x = %d\n", x); printf("x times 10 = %d\n", times10(x)); printf("x = %d\n", x); y = rand() % ; printf("y = %d\n", y); printf("y times 10 = %d\n", times10(y)); return 0; } int times10(int x) { x = x * 10; return x; }

21 Notes on previous example Different variables with the same name can exist as long as their scopes differ (x in main, x in times10) Two variables with the same name are still two different variables! Parameter name and argument name need not match, and usually don't

22 Why not use global variables? Though global variables are legal in C, they are not considered good programming practice A global variable can be changed by any function A change made by one function may cause unexpected behavior in another: side effect The more complex the code, the greater the likelihood of side effects Scope resolution can get tricky (see next example) Best practice: use parameter passing

23 Example: global variable #include <stdio.h> int x = 7; /* global variable */ void changexto42(); int main (){ printf("x=%d\n", x); int x; /* local variable */ printf("enter new value for x: "); scanf("%d", &x); printf("x=%d\n", x); changexto42(); printf("x=%d\n", x); return 0; } void changexto42(){ x=42; }

24 Functions & incremental development As programs become more complicated, using multiple functions enables the programmer to develop the code in discrete steps Instead of attempting the code the whole problem at once, write and test one function at a time

25 Function stubs Stubs are minimal functions that don't really perform the work they're supposed to do, but act as placeholders so that other parts of the program can be tested The next example illustrates this technique

26 Example, part 1 #include <stdio.h> double calcdistance(double d1, double d2); double calcfuel(double amt1, double amt2); double calcmiles (double d, double f); int main() /* test driver */ { double startmiles, finishmiles, startgas, finishgas, mpg;... printf("distance traveled: %.1lf miles\n", calcdistance(startmiles, finishmiles)); printf("fuel consumed: %.1lf gallons\n", calcfuel(startgas, finishgas)); printf("gas mileage for trip: %.1lf mpg\n", calcmiles(calcdistance(startmiles, finishmiles), calcfuel(startgas, finishgas))); return 0; }

27 Example, part 2 /* stubs */ double calcdistance(double d1, double d2) { printf("calcdistance: NOT DONE YET\n"); return 1; } double calcfuel(double amt1, double amt2) { printf("calcfuel: NOT DONE YET\n"); return 1; } double calcmiles (double d, double f) { printf("calcmiles: NOT DONE YET\n"); return 1; }

28 Passing parameters by reference As we have seen, a function can take from 0 to many arguments, but can only return either 0 or 1 value If we want to get multiple values out of a function, we can do so by altering the way we pass arguments in We have already seen and used an example of this technique, with the scanf() function

29 A closer look at scanf() As we've been using it, scanf() takes two arguments: A format specifier indicating the data type of the value to be read The name of the variable to hold the value, preceded by the '&' character '&' is an operator meaning address of The argument we're passing to the function is the address of a variable A parameter that specifies such an argument is called a reference parameter

30 Example Suppose we want to write a function that exchanges the values of two variables The action would look something like this:

31 First Attempt #include <stdio.h> void swap (int x, int y); int main () { int a, b; printf("enter first number: "); scanf("%d", &a); printf("enter second number: "); scanf("%d", &b); printf("the values are a: %d and b: %d\n", a, b); printf("calling swap function... "); swap(a, b); printf("the values are a: %d and b: %d\n", a, b); } void swap (int x, int y) { int tmp = x; x = y; y = tmp; }

32 What happened Values for variables a and b are passed to parameters x and y In effect, x=a; and y=b; Values of x and y are swapped When function returns, a and b are unchanged The process described above is normal for parameter passing: it's known as pass by value

33 Pass by value When we practice pass by value, we are passing a copy of the argument's value to assign to the parameter Since all operations within the function are taking place with the copy, there is no change to the original argument

34 Pass by reference To make the swap() function work, we have to change our way of passing parameters If we actually want the function to change the value(s) of the original argument(s), we pass by reference Passing by reference requires us to use pointer notation

35 Pointers A pointer is a variable that holds the memory address of stored data, rather than the data itself The pointer is thus an indirect reference to the data

36 Pointer notation Declaring a pointer variable: Data type *name; Assigning a value to a pointer variable: name = &somevariable; (where somevariable is previously declared) Assigning a value to the memory the pointer references (aka pointer dereferencing): *name = value;

37 Example/illustration #include <stdio.h> int main() { int x = 7; int *p = &x; printf("x=%d\n", x); *p = 42; printf("x=%d\n", x); return 0; }

38 Swap function revisited We can use pass by reference, with pointer parameters, to make the swap function work as originally intended Key points: Parameters declared as pointers: void swap (int *x, int *y) Arguments passed as addresses: swap(&a, &b); Dereference pointers when assigning values: *x = *y;

39 Working swap function #include <stdio.h> void swap (int *x, int *y); int main () { int a, b; printf("enter first number: "); scanf("%d", &a); printf("enter second number: "); scanf("%d", &b); printf("the values are a: %d and b: %d\n", a, b); printf("calling swap function... "); swap(&a, &b); printf("the values are a: %d and b: %d\n", a, b); return 0; } void swap (int *x, int *y) { int tmp = *x; *x = *y; *y = tmp; }