1. C Programming Functions Program Organization Separate Compilation

2. Functions vs. Methods Java classes include methods which can be called from any code with appropriate access (recall public methods)Java classes include methods which can be called from any code with appropriate access (recall public methods) C functions are like Java methods, but they don’t belong to any class. Functions are defined in a file and may be either global to your program or local to (“private” in) the file in which they are defined*.C functions are like Java methods, but they don’t belong to any class. Functions are defined in a file and may be either global to your program or local to (“private” in) the file in which they are defined*. Like Java methods, C functionsLike Java methods, C functions –Have a name –Have a return type –May have parameters Unlike Java methods, a function in C is uniquely identified by its name. Therefore, there is no concept of method overloading in C as there is in Java. There can be only one main( ) function in a C application.Unlike Java methods, a function in C is uniquely identified by its name. Therefore, there is no concept of method overloading in C as there is in Java. There can be only one main( ) function in a C application. See the course coding standards for function naming conventions.See the course coding standards for function naming conventions.the course coding standardsthe course coding standards

3. Arguments vs Parameters A parameter is defined in the function definition. It is a place holder for the argument during function execution A parameter is defined in the function definition. It is a place holder for the argument during function execution void printInt( int n ) // n is the parameter { printf( “%20d\n”, n); } An argument is a value passed to a function when the function is called An argument is a value passed to a function when the function is called int age = 42; printInt( age );// age is the argument These terms are often (incorrectly) used interchangeably, but the context is usually clear These terms are often (incorrectly) used interchangeably, but the context is usually clear

4. Passing Arguments Primitive types (int, char, float, etc) and structs are passed to function “by value” Primitive types (int, char, float, etc) and structs are passed to function “by value” – A copy of the argument is passed to the function – Changing the parameter within the function has no effect on the argument in the calling code Arrays are passed “by reference” Arrays are passed “by reference” – A copy of the address of the array is passed to the function The parameter is an “alias” for the argument – References to array elements in the function refer to array elements in the calling code – Array parameters which are not intended to be changed by a function should be qualified as const

5. Passing Arguments /* ages.c */ #include void growOlder( int a[ ], int size) { int k; for (k = 0; k < size; k++) ++a[ k ]; } int avgAge( const int array[ ], int size) { int k, sum = 0; for (k = 0; k < size; k++) sum += array[ k ]; return sum / size; } int main( ) { int nrStudents = 6; int ages[ 6 ] = {19, 18, 17, 22, 44, 55}; growOlder( ages, nrStudents ); int avg = avgAge( ages, nrStudents ); printf(“The average age is %d\n”, avg); return 0; }

6. A Simple C Program /* sample.c */ #include typedef double Radius; #define PI 3.1415 /* given the radius, calculates the area of a circle */ double circleArea( Radius radius ) { return ( PI * radius * radius ); } // given the radius, calcs the circumference of a circle double calcCircumference( Radius radius ) { return (2 * PI * radius ); } int main( ) { Radius radius = 4.5; double area = circleArea( radius ); double circumference = calcCircumference( radius ); printf (“Area = %10.2f, Circumference = %10.2f\n”, area, circumference); return 0; }

7. Reusable Functions The functions circleArea( ) and calcCircumference( ) are general functions that may be used by multiple applications.The functions circleArea( ) and calcCircumference( ) are general functions that may be used by multiple applications. To make them available to multiple applications without duplicating the code we must place them into a separate.c file.To make them available to multiple applications without duplicating the code we must place them into a separate.c file. However, recall that the compiler requires that we must provide the function prototypes to the calling code. We do this by placing the prototypes and supporting declarations into a header (.h) file which is then included in.c files that wish to call the functions.However, recall that the compiler requires that we must provide the function prototypes to the calling code. We do this by placing the prototypes and supporting declarations into a header (.h) file which is then included in.c files that wish to call the functions.

8. circleUtils.h A header (.h) file is the public interface (function prototypes) for its corresponding.c file.A header (.h) file is the public interface (function prototypes) for its corresponding.c file. It contains all definitions required by the prototypes so that a.c file that includes it compilesIt contains all definitions required by the prototypes so that a.c file that includes it compiles /* circleUtils.h*/ // #includes required by the prototypes, if any /* supporting typedefs and #defines required by the prototypes */ typedef double Radius; /* function prototypes */ // given the radius, returns the area of a circle double circleArea( Radius radius ); // given the radius, calcs the circumference of a circle double calcCircumference( Radius radius );

9. circleUtils.c /* circleUtils.c ** Utilites for circle calculations */ #include “circleUtils.h” #define PI 3.1415// why not in the.h file?? /* given the radius, calculates the area of a circle */ double circleArea( Radius radius ) { return ( PI * radius * radius ); } // given the radius, calcs the circumference of a circle double calcCircumference( Radius radius ) { return (2 * PI * radius ); }

10. Sample Code Revisited /* sample.c */ #include #include “circleUtils.h” int main( ) { Radius radius = 4.5; double area = circleArea( radius ); double circumference = calcCircumference( radius ); printf (“Area = %lf, Circumference = %lf\n”, area, circumference); return 0; }

11. Header Files When a file contains functions to be reused in several programs, their prototypes and important and are placed into a header ( ) that is then included where needed.When a file contains functions to be reused in several programs, their prototypes and important #defines and typedefs are placed into a header (.h ) that is then included where needed. Each file should be “stand alone”. That is, it should declare any and needed by the prototypes and any files it needs to avoid compiler errors. The file should contain everything needed to successfully compile any file that includes it.Each.h file should be “stand alone”. That is, it should declare any #define and typedef needed by the prototypes and #include any.h files it needs to avoid compiler errors. The.h file should contain everything needed to successfully compile any.c file that includes it. In this example, the prototypes for and are placed into the file which would then be included in and any other file that uses and / or.In this example, the prototypes for circleArea() and calcCircumference( ) are placed into the file circleUtils.h which would then be included in circleUtils.c and any other.c file that uses circleArea( ) and / or calcCircumference( ).

12. Guarding Header Files Because a file may include other files, there is the possibility that one or more files may unintentionally be included in a single file more than once, leading to compiler errors (multiple name definitions).Because a.h file may include other.h files, there is the possibility that one or more.h files may unintentionally be included in a single.c file more than once, leading to compiler errors (multiple name definitions). To avoid these errors, files should be “guarded” using the compiler directives (read as “if not defined”) andTo avoid these errors,.h files should be “guarded” using the compiler directives #ifndef (read as “if not defined”) and #endif

13. Guarded circleUtils.h #ifndef CIRCLEUTIL_H #define CIRCLEUTIL_H /* circleUtils.h */ /* #include.h files as necessary */ /* supporting typedefs and #defines */ typedef double Radius; /* function prototypes */ // given the radius, returns the area of a circle double circleArea( Radius radius ); // given the radius, calcs the circumference of a circle double calcCircumference( Radius radius ); #endif

14. 1/20/10 Compiling and linking When a program’s code is separated into multiple files, we must compile each file and then link the resulting files to create an executable program.When a program’s code is separated into multiple.c files, we must compile each.c file and then link the resulting.o files to create an executable program. The files may be compiled separately and then linked together. The flag in the first two command tells to “compile only” which results in the creation of (object) files. In the 3 rd command, the presence of the extension tells to link the files into an executableThe files may be compiled separately and then linked together. The -c flag in the first two command tells gcc to “compile only” which results in the creation of.o (object) files. In the 3 rd command, the presence of the.o extension tells gcc to link the files into an executable gcc -c -Wall circleUtils.c gcc -c -Wall sample.c gcc -Wall -o sample sample.o circleutils.o Or if there only a few files, compiling and linking can be done all in one stepOr if there only a few files, compiling and linking can be done all in one step –gcc -Wall -o sample sample.c circleUtils.c

15. Compiler vs linker The compiler translates one.c file into a.o file The compiler translates one.c file into a.o file – Verifies that all functions are being called correctly – Verifies that all variables exist – Verifies language syntax The linker combines multiple.o files (and C libraries) to create an executable The linker combines multiple.o files (and C libraries) to create an executable – “Finds” functions called by one.c/.o file, but defined in another E.g. printf( ), scanf( ) – “Finds” global variables used by one.c/.o file, but defined in another (more on this soon) Both can be invoked with gcc (see previous lecture) Both can be invoked with gcc (see previous lecture)

16. Linking with C libraries By default, the standard C library which includes printf, scanf and char and string functions is always linked with your program. By default, the standard C library which includes printf, scanf and char and string functions is always linked with your program. Other libraries such as the math library must be explicitly linked with your code. Other libraries such as the math library must be explicitly linked with your code. The names of the C libraries alll have the form. The standard C library is. The C math library is. The names of the C libraries alll have the form libxxx.a. The standard C library is libc.a. The C math library is libm.a. Specify libraries to be linked using the flag and the part of the library name. Specify libraries to be linked using the -l flag and the xxx part of the library name. – E.g. to link the math library with your program, use gcc -Wall -o sample sample.c circleUtils.c -lm

17. Project Organization main( ) is generally defined in its own.c file and generally just calls helper functionsmain( ) is generally defined in its own.c file and generally just calls helper functions –E.g. project1.c Project-specific helper functions may be in the same.c file as main( )Project-specific helper functions may be in the same.c file as main( ) main( ) comes first Helper function order that makes sense to you Reusable functions in their own.c fileReusable functions in their own.c file –Group related functions in the same file –E.g. circleUtils.c Prototypes, typedefs, #defines, etc. for reusable function in a.h filePrototypes, typedefs, #defines, etc. for reusable function in a.h file –Same file root name as the.c file. E.g. circleUtils.h

18. Variable Scope and Lifetime The scope of a variable refers to that part of a program that may refer to the variable.The scope of a variable refers to that part of a program that may refer to the variable. The lifetime of a variable refers to the time in which a variable occupies a place in memoryThe lifetime of a variable refers to the time in which a variable occupies a place in memory The scope and lifetime of a variable are determined by how and where the variable is definedThe scope and lifetime of a variable are determined by how and where the variable is defined

19. static and extern The keyword static is used to The keyword static is used to – Limit the scope of a function or global variable – Extend the lifetime of a variable The keyword extern is used to The keyword extern is used to – Inform the compiler that a (global) variable is defined in a different.c file

20. Function Scope All functions not found in the.c file that calls them are considered external because standard C does not allow nesting of function definitions.All functions not found in the.c file that calls them are considered external because standard C does not allow nesting of function definitions. –So no “extern” declaration is needed –All functions may be called from any.c file in your project unless they are also declared as static. –The linker will “find” external functions called from one.c file but defined in a different.c file functions may only be called from within the.c file in which they are definedstatic functions may only be called from within the.c file in which they are defined Their scope is limited

21. Local variables variables are defined within the opening and closing braces of a function, loop, if-statement, etc. (a code “block”). Function parameters are considered local variables in their function.Local variables are defined within the opening and closing braces of a function, loop, if-statement, etc. (a code “block”). Function parameters are considered local variables in their function. –Are usable only within the block in which they are defined –Exist only during the execution of the block unless also defined as static –Initialized variables are reinitialized each time the block is executed (if not defined as static) –static local variables retain their values for the duration of your program. When used in functions, they retain their values between calls to the function.

22. Global Variables Global (external) variables are defined outside of any function, typically near the top of a.c file.Global (external) variables are defined outside of any function, typically near the top of a.c file. –May be used anywhere in the.c file in which they are defined. –Exist for the duration of your program –May be used by any other.c file in your application that declares them as “extern” unless also defined as static (see below) –Static global variables may only be used in the.c file that declares them –“extern” declarations for global variables should be placed into a header file

23. randomInt.c /* a global variable to be used by code in other.c files. ** This variable exists until the program ends ** Other.c files must declare this variable as " extern “ */ long randomInt; /* a function that can be called from any other function ** sets randomInt to a value from 1 to max, inclusive */ void getRandomInt( int max ) { randomInt = getNext( ); } /* a function that can only be called from functions within this file */ static long getNext( ) { /* lastRandom is a local variable that can only be used inside this function, but persists between calls to this function */ static long lastRandom = 100001 ; lastRandom = (lastRandom * 125) % 2796203; return (lastRandom % max) + 1; }

24. randomInt.h #ifndef RANDOMINT_H #define RANDOMINT_H // global variable in randomint.c extern int randomInt; // prototypes for non-static (“public”) // functions in randomInt.c void getRandomInt( int max ); #endif

25. variableScope.c - part 1 #include // extern definition of randomInt and prototype for getRandomInt #include “randomInt.h” /* a global variable that can only be used by functions in this.c file */ static int inputValue; /* a function that can only be called by other functions in this.c file */ static void inputPositiveInt( char prompt[ ] ) { /* init to invalid value to enter while loop */ inputValue = -1; while (inputValue <= 0) { printf( "%s", prompt); scanf( "%d", &inputValue); }

26. variableScope.c - part 2 /* main is the entry point for all programs */ int main( ) { /* local/automatic variables that can only be used in this function and that are destroyed when the function ends */ int i, maxValue, nrValues; inputPositiveInt("Input max random value to generate: "); maxValue = inputValue; inputPositiveInt("Input number of random ints to generate: "); nrValues = inputValue; for (i = 0; i < nrValues; i++) { getRandomInt( maxValue ); printf( “%d: %d\n", i + 1, randomInt ); } return 0; }

27. The make Utility Typing out the gcc commands for a project gets less appealing as the project gets bigger. The "make" utility automates the process of compiling and linking. With make, the programmer specifies what the files are in the project and how they fit together. make takes care of the appropriate compile and link steps. make can speed up your compiles since it is smart enough to know that if you have 10.c files but you have only changed one, then only that one file needs to be compiled before the link step. make has some complex features, but using it for simple things is pretty easy. This slide and those that follow are adapted from Section 2 of “UnixProgrammingTools.pdf” by Nick Parlante, et al at Stanford. Used with permission.UnixProgrammingTools.pdf

28. How make works You tell make what files are in your project, how they fit together, how to compile, and how to link them by creating a file that make reads and interprets You tell make what files are in your project, how they fit together, how to compile, and how to link them by creating a file that make reads and interprets – By default, make looks for a file named either “makefile” or “Makefile” At the Unix console, simply type the command make to compile all necessary files and create a new executable At the Unix console, simply type the command make to compile all necessary files and create a new executable unix> make make can perform other tasks defined in the makefile as well (more on this later) make can perform other tasks defined in the makefile as well (more on this later)

29. The makefile A makefile consists of variable definitions, dependency/build rules and comments A makefile consists of variable definitions, dependency/build rules and comments Comments begin with the ‘#’ character and extend to the end of the line Comments begin with the ‘#’ character and extend to the end of the line # makefile for project 1 # name, date, etc

30. The makefile (2) Variable definitions Variable definitions – A variable name is defined to represent a string of text, similar to #define in C. They are most often used to represent names of files, directories, and the compiler. – Variable are defined simply by setting them to some value (string) – The most common variables are typically CC -- the name of your C compiler CFLAGS -- the set of flags that you wish to pass to the compiler LDFLAGS -- the set of flags that you wish to pass to the linker OBJS -- the set of object (.o) files that are linked together to create your executable To use a variable, use the dollar sign ($) followed by the name of the variable in parenthesis or curly braces To use a variable, use the dollar sign ($) followed by the name of the variable in parenthesis or curly braces CC = /usr/local/bin/gcc CFLAGS = -g -Wall $(CC) $(CFLAGS) -c main.c Variables that are not initialized are set to the empty string Variables that are not initialized are set to the empty string

31. The make file (3) A dependency/build rule defines how to make a target based on changes to the files on which the target depends. A dependency/build rule defines how to make a target based on changes to the files on which the target depends. The order of the rules is irrelevant, except that the first rule is the default rule -- the rule that will be used when is executed with no arguments The order of the rules is irrelevant, except that the first rule is the default rule -- the rule that will be used when make is executed with no arguments A dependency/build rule is made up of two parts A dependency/build rule is made up of two parts – A dependency line followed by one or more command lines

32. The make file (4) Example dependency/build rule Example dependency/build rule sample.o : sample.c circleUtils.h $(CC) $(CFLAGS) -c sample.c The first (dependency) line of this rule says that must be rebuilt whenever or changes. Generally a.o file depends on its own.c file and any non-library.h files it. In this example, we would expect that s The first (dependency) line of this rule says that sample.o must be rebuilt whenever sample.c or circleUtils.h changes. Generally a.o file depends on its own.c file and any non-library.h files it #includes. In this example, we would expect that sample.c #includes circleUtils.h The second (command) line tells make how to rebuild sample.o The second (command) line tells make how to rebuild sample.o – Gotcha -- the command line MUST be indented with a TAB character. Spaces won’t do. This can be a problem when cutting/pasting the contents of a makefile from a terminal screen. Some editors will automatically change a TAB into spaces.

33. Sample makefile See /afs/umbc.edu/users/c/m/cmsc313/pub/code/makefile

34. make features The utility has some built-in default rules. The make utility has some built-in default rules. In particular, the default rule for C files is $(CC) $(CFLAGS) -c source-file.c In particular, the default rule for C files is $(CC) $(CFLAGS) -c source-file.c Special syntax can be used to create the list of the.o files OBJS = $(SRCS:.c=.o) Special syntax can be used to create the list of the.o files OBJS = $(SRCS:.c=.o)

35. Other Function Topics Automatic type promotion Automatic type promotion Passing 2-d Arrays Passing 2-d Arrays Recursion Recursion In-line functions In-line functions

36. Auto Type Conversion As we’ve seen, the compiler can and will automatically convert a “small” data type to a “larger” data type without problems. As we’ve seen, the compiler can and will automatically convert a “small” data type to a “larger” data type without problems. char initial = ‘B’; short age = 42; int intAge = 42, intInitial = initial; long longAge = age; The same type conversion occurs for function arguments. The same type conversion occurs for function arguments. short myAge = 42, yourAge = 33; long max( long a, long b); long older = max ( myAge, yourAge);

37. Passing 2-D Arrays Passing a 2-d array to a function is similar to passing a 1-d array Passing a 2-d array to a function is similar to passing a 1-d array Basic function prototype Basic function prototype void printChessBoard( char [ 8 ][ 8 ] theBoard); Calling the function Calling the function char chessBoard[ 8 ] [ 8 ]; printChessBoard( chessBoard ); As we will see, the compiler needs to know the size of each row, but not the number of rows. This allows an alternative prototype As we will see, the compiler needs to know the size of each row, but not the number of rows. This allows an alternative prototype void printChessBoard( char[ ] [ 8 ] theBoard );

38. Recursion C functions may be called recursively.C functions may be called recursively. –Typically a function calls itself A properly written recursive function has the following propertiesA properly written recursive function has the following properties –A “base case” - a condition which does NOT make a recursive call because a simple solution exists –A recursive call with a condition (usually a parameter value) that is closer to the base case than the condition (parameter value) of the current function call Each invocation of the function gets its own set of arguments and local variablesEach invocation of the function gets its own set of arguments and local variables We’ll see how recursion is implemented laterWe’ll see how recursion is implemented later

39. Recursion Example /* print an integer in decimal ** K & R page 87 (may fail on largest negative int) */ #include void printd( int n ) { if ( n < 0 ) { printf( “-” ); n = -n; } if ( n / 10 )/* (n / 10 != 0) -- more than 1 digit */ printd( n / 10 );/* recursive call: n has 1 less digit */ printf( “%c”, n % 10 + ‘0’); /* base case --- 1 digit */ }

40. Recursive Exercise Complete the following recursive function that sums all of the integers from 1 to N int sumToN( int N ) { if (____________________) // base case return N; else// recursive call return ______________________; }

41. Inline Functions C99 onlyC99 only Short functions may be defined as “”. This is a suggestion to the compiler that calls to the function should be replaced by the body of the function.Short functions may be defined as “ inline ”. This is a suggestion to the compiler that calls to the function should be replaced by the body of the function. functions provide code structure and readability and (may) increase performanceinline functions provide code structure and readability and (may) increase performance inline bool isEven( int n ) { return n % 2 == 0; } inline max( int a, int b ) { return a > b ? a : b; }