Programming. Projects with Multiple Files

Size: px

Start display at page:

Download "Programming. Projects with Multiple Files"

Piers McGee
5 years ago
Views:

1 Programming Projects with Multiple Files

2 Summary } GCC } Multiple source files 2

3 Source Code with Multiple Files } Make multiple, separate source code files which can be combined into one executable } Example: } One file *.c to manipulate the dates } One file *.c to manipulate the names } One file *.c to read/write files } One file for the main function } Each file must have functions that are correlated: } Change some type of data structure } Are somewhat connected 3

4 Definitions } Associated to each *.c file we must have: } One *.h file } Each header file (*.h) must be included: } By the corresponding *.c } By every file that needs the types thereby defined 4

5 Example: Date and ID data.h } typedef struct data } { } data.c } #include data.h } int comparadata( ) } { } } } } BI.h } #include data.h } typedef stuct BI } { } BI.c } #include BI.h } void le_bi(bi *b) } { } } } 5

6 Source and Header Files } Header file (*.h) should have } Declaration of any constants } Declaration of any types } Declaration of any functions } Everything needed for other files to know } Header file must not have: } Declaration of variables } Function definitions } Source file (*.c) includes the necessary header files } To know the functions and types needed } You cannot include source files.c } Only source files must be compiled 6

7 Header Files: Example hanoi.c: hanoi.h: #define NUMDISKS 6 #define NUMPINS 3 I have two.c files in the same program. Both need to know NUMDISKS and NUMPINS. So, I put that information in a header file: hanoi.h 7 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include hanoi.h bool CheckDone(int tower[numpins][numdisks]); display.c: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include hanoi.h void DisplayTower(int tower[numpins][numdisks]) { }

8 How GCC compiles? 8

9 Compiling } Compiler translates the C source code into object code what the machine actually understands } Machine-specific } Each line represents either a piece of data or a machine-level instruction } To create the assembly code: gcc -c preproc.c preprocessor (# commands) Expanded C code Object Code (.o file) Compiler 9 C source file

10 Object Files } Files already compiled: } Translated to machine code } Dependent on the processor and operative system } Contains parts of the programs } Maybe used in several programs 10

11 Linking } Object file may not be directly executable } Missing some parts } Still has some names to be resolved } The linker (ld) takes multiple object files (.o) and puts them together into one executable file } Resolves references to calls from one file to another } Linking is important as it allows multiple, separate files to be brought together 11

12 Separate Compilation } For large, complex programs, the best thing is to break your files into separate.c and.h files } Can debug each separately, then reuse } Can distribute pieces to other so they can incorporate into their code without changing their code (just link it in) 12

13 Example of Separate Compilation mainprog.c shapes.h shapes.c math.h mainprog gcc -c shapes.c gcc c mainprog.c gcc lm mainprog.o shapes.o o mainprog gcc lm shapes.c mainprog.c o mainprog 13

14 GCC Compilation Pipeline } Preprocessing (gcc E code.c > code.i) } Removes preprocessor directives (commands that start with #) } Produces code.i Don t use it directly! } Compiling (gcc o code.o c code.i) } Converts source code to machine language with unresolved directives } Produces the code.o binary } Linking (gcc lm o code code.o) } Creates machine language executable } Produces the code binary by linking with the math library (-lm) 14

15 #include } Include header files that contain declarations necessary for compiling code } Declarations provide the proper types, but not the actual definitions (the actual code) } You need to create our own.h files to share information between.c files. # ifndef _STDIO_H 15 data.c #include <stdio.h> #include functions.h int main() { double x = 1; printf( Sinc(x) = %f\n, Sinc(x)); } # if!defined need_file &&!defined need FILE # define _STDIO_H 1 # include <features.h> BEGIN_DECLS functions.h double Sinc(double x);

16 #define } #defines a preprocessor variable } Every place the variable occurs, the definition will be substituted as code } Syntax: #define var_name var_definition 16

17 #ifdef, #ifndef, #if } Example: surround code that might be included. Include for compilation if necessary. #ifdef DEBUG. #endif #ifndef DEBUG #endif if(num == 1) { /* This is the only time we actually move a disk */ DisplayTower(tower); #if 0 printf("press return"); fgets(cmd, sizeof(cmd), stdin); #endif This code is not going to be compiled. Better than trying to comment out the block, which may have comments already. } MoveDisk(tower, fm, to); return; 17

An #include Problem } What happens when we compile foo.c? } gcc -Wall -g -o foo foo.c } In file included from ht.h:1, from foo.c:2: } ll.h:1: error: redefinition of typedef LinkedList } ll.

18 An #include Problem } What happens when we compile foo.c? } gcc -Wall -g -o foo foo.c } In file included from ht.h:1, from foo.c:2: } ll.h:1: error: redefinition of typedef LinkedList } ll.h:1: note: previous declaration of LinkedList was here } foo.c includes ll.h twice (2 nd time via ht.h) } typedef shows up twice ll.h: typedef void *LinkedList; ht.h: #include ll.h typedef void *HashTable; // hypothetical function LinkedList HTKeyList(HashTable t); 18 foo.c: #include "ll.h" #include "ht.h" int main(int argc, char **argv) { //... do stuff here... return 0; }

19 Include Guards hanoi.h: #ifndef HANOI_H #define HANOI_H #define NUMDISKS 6 #define NUMPINS 3 #endif solve.h: hanoi.c: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include solve.h #include hanoi.h bool CheckDone(int tower[numpins][numdisks]); #ifndef SOLVE_H #define SOLVE_H #include hanoi.h void Autosolve(int tower[numpins][numdisks]); Include Guards: Conditional compilation code that protects a section of code in a header from being compiled more than once. #endif 19

20 Macros } You can pass arguments to macros } Be careful with precedence issues, use parenthesis #define ODD(x) ((x) % 2!= 0) void foo(void) { if ( ODD(5) ) printf("5 is odd!\n"); } Preprocessor void foo(void) { if ( ((5) % 2!= 0) ) printf("5 is odd!\n"); } #define ODD(x) ((x) % 2!= 0) #define BAD(x) x % 2!= 0 ODD(5 + 1); BAD(5 + 1); Preprocessor ((5 + 1) % 2!= 0); % 2!= 0; 20

21 Conditional Compilation } It is possible to change what is being compiled! #ifdef TRACE #define ENTER(f) printf("entering %s\n", f); #define EXIT(f) printf("exiting %s\n", f); #else #define ENTER(f) #define EXIT(f) #endif void pr(int n) { ENTER("pr"); printf("n = %d\n",n); EXIT("pr"); } 21

22 Defining Symbols } Besides #defines in the code, preprocessor values can be given on the gcc command } gcc -Wall -g -DTRACE -o ifdef ifdef.c } assert is controlled the same way - #define NDEBUG and asserts expand to empty (it s a macro) } gcc -Wall -g -DNDEBUG -o faster usesassert.c 22

23 External Linkage } A global variable defined in one file can be visible in another? } Yes! The variable is defined in one file, declared in the other(s) } When the program is linked, the symbol resolves to one location Counter is the same variable in both files! 23

24 Internal Linkage } The same name can also refer to different variables } The variables must be defined in each file } When the program is linked, the symbols resolve two locations Counter is a different variable in both files! 24

25 Some Considerations } Every global (variables and functions) is extern by default. } Unless you specify the static specifier, if some other module uses the same name, you ll end up with a collision! } Best case: compiler error } Worst case: stomp all over each other } Good practices: } Use static to defend your globals (hide your private stuff!) } Place external declarations in a module s header file 25

26 To Review } Google is your friend! 26

CSE 333 Lecture 7 - final C details

CSE 333 Lecture 7 - final C details Steve Gribble Department of Computer Science & Engineering University of Washington Today s topics: - a few final C details header guards and other preprocessor tricks