1. Functions and scope Confidence In scope Reference: K&K textbook, Chapter 4

2. Postconditions You should be able to define function prototypes draw pictures of the runtime stack during execution of code (show understanding of memory model) state scope of any identifier in a C program, ie visibility, hiding Draw pictures of memory based on classes Explain reason for initialisation restrictions compile and run multi-file programs

3. define function prototypes draw pictures of the runtime stack during execution of code (show understanding of memory model) state scope of any identifier in a C program, ie visibility, hiding Draw pictures of memory based on classes Explain reason for initialisation restrictions compile and run multi-file programs

4. Function prototypes /*-------------------------------*/ do_that( ) { double *p;... p = do_this(*p); } /*-------------------------------*/ double *do_this(double a) { double *p;... p = do_that( ); }

5. double *do_this(double); /*-------------------------------*/ do_that( ) { double *p;... p = do_this(*p); } /*-------------------------------*/ double *do_this(double a) { double *p;... p = do_that( ); } Function prototype

6. define function prototypes draw pictures of the runtime stack during execution of code (show understanding of memory model) state scope of any identifier in a C program, ie visibility, hiding Draw pictures of memory based on classes Explain reason for initialisation restrictions compile and run multi-file programs

7. main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); } Do_Input( ){ int i1, i2;... } Process_and_Print( ){ int p1, p2;... calc(p1, p2); } calc(int x, int y){ int c1;... }

8. Process_and_Print( ){ int p1, p2;... calc(p1, p2); } Do_Input( ){ int i1, i2;... } calc(int x, int y){ int c1;... } main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); }

9. Order of function execution main Do_Input Process_and_Print calc Static v dynamic structure Order of functions does not affect runtime structure

10. Scope, static v dynamic structure Static structure of code –Holds from time code is written Run time structures –Differ according to data in individual runs Is scope defined by the static structure or the dynamic structure?

11. Terminology: scope…. Scope = Visibility Visible v hidden

12. m1 m2 m3 m4 main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); } Do_Input( ){ int i1, i2;... } Process_and_Print( ){ int p1, p2;... calc(p1, p2); } calc(int x, int y){ int c1;... }

13. Housekeeping data for Do_Input i1 i2 m1 m2 m3 m4 main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); } Do_Input( ){ int i1, i2;... } Process_and_Print( ){ int p1, p2;... calc(p1, p2); } calc(int x, int y){ int c1;... }

14. m1 m2 m3 m4 main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); } Do_Input( ){ int i1, i2;... } Process_and_Print( ){ int p1, p2;... calc(p1, p2); } calc(int x, int y){ int c1;... }

15. Housekeeping data for Process_and_Print p1 p2 m1 m2 m3 m4 main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); } Do_Input( ){ int i1, i2;... } Process_and_Print( ){ int p1, p2;... calc(p1, p2); } calc(int x, int y){ int c1;... }

16. Housekeeping data for calc x y c1 Housekeeping data for Process_and_Print p1 p2 m1 m2 m3 m4 main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); } Do_Input( ){ int i1, i2;... } Process_and_Print( ){ int p1, p2;... calc(p1, p2); } calc(int x, int y){ int c1;... }

17. Housekeeping data for Process_and_Print p1 p2 m1 m2 m3 m4 main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); } Do_Input( ){ int i1, i2;... } Process_and_Print( ){ int p1, p2;... calc(p1, p2); } calc(int x, int y){ int c1;... }

18. m1 m2 m3 m4 main ( ){ int m1, m2, m3, m4;... Do_Input( ); Process_and_Print( ); } Do_Input( ){ int i1, i2;... } Process_and_Print( ){ int p1, p2;... calc(p1, p2); } calc(int x, int y){ int c1;... }

19. define function prototypes draw pictures of the runtime stack during execution of code (show understanding of memory model) state scope of any identifier in a C program, ie visibility, hiding Draw pictures of memory based on classes Explain reason for initialisation restrictions compile and run multi-file programs

20. Communication between functions Arguments (aka parameters) Global data Which is better?

21. Scope Within blocks Within a file Between files

22. Static structure of programs Typical program structure global declarations main function other functions and global declarations interspersed Note: need function prototypes before the function is used

23. Static structure of functions Function header Declarations Function body int Dojob(int age) { int jam; … statements of the function body }

24. Static structure of blocks Declarations Block body while …. { int jam; … statements of the block body }

25. {/* outer block */ int a; int b;... { /* inner block */ char a; int d;... }... } Scope of variable identifiers outer a b inner a d

26. int main( ){ int a2;... } fileA float a3; char A(char a4){ char a5;... } functionsvariables a1 a2 a3 a4 a5 int a1; main A

27. Scope between files Importing variable identifiers extern int a1; Hiding variable and function identifiers static

28. Scope between files See example on page 75, Chapter 4 of textbook

29. Exercise How to make a3 accessible to main? To B2? What happens if we added to start of fileA: int b1; and what about int b2; What is the effect of adding to start of fileB: extern char b1; What happens if we add to start of fileA: extern int B2();

30. Storage classes auto (stack) static register (optimisation - obsolete) extern You need to distinguish these in drawings of memory models

31. Storage classes stack global/static You need to distinguish these in drawings of memory models

32. Storage classes – memory models Dynamic, volatile memory, change through the execution of the program –auto (stack) –register Persistent memory – stable for the duration of the runtime of the program –static –extern You need to distinguish these in drawings of memory models

33. Initialisations - globals #define BOUND 100 static int a = 72 * sizeof(int); int b = BOUND; extern char x; int y; Volatile storage Persistent storage registerauto heapextern, static

34. Initialisations - globals #define BOUND 100 static int a = 72 * sizeof(int); int b = BOUND; extern char x; int y; Volatile storage Persistent storage registerauto heapextern, static

35. Initialisations - globals #define BOUND 100 static int a = 72 * sizeof(int); /* constant expression */ int b = BOUND; /* constant expression */ extern char x; /* cannot be initialised here */ int y; /* defaults to zero */

36. Initialisations - local #define BOUND 100 static int a = 72 * sizeof(int); int b = BOUND; extern char x; int y; fnA( ) { static int c = BOUND + 7; int d = a + fnXX(); register int e = b; extern char g;... }

37. Initialisations - local fnA( ) { static int c = BOUND + 7; /* constant expression */ int d = a + fnXX(); /* any expression */ register int e = b; /* any expression */ extern char g; /* cannot be initialised */... }

38. define function prototypes draw pictures of the runtime stack during execution of code (show understanding of memory model) state scope of any identifier in a C program, ie visibility, hiding Draw pictures of memory based on classes Explain reason for initialisation restrictions compile and run multi-file programs

39. Compiling multi-file programs Preprocessor C compiler Assembler Linker Source code Name.c Assembly code Name.s Object code Name.o a.out

40. Compiling multi-file programs Compiler can stop at the.o stage Linker takes one or more.o files and produces the a.out Use the ‘-c’ flag to gcc to produce the.o

41. Compiling multi-file programs bash$ gcc -c doin.c proc.c dout.c bash$ gcc doin.o proc.o dout.o –o pds bash$ gcc -c proc.c bash$ gcc doin.o proc.o dout.o -o pds

42. Using functions from the standard libraries #include double sin(double); double n; double x; scanf("%f", &n); x = sin(n); __________________________________ gcc -lm... Library name is ‘m’

43. Postconditions You should be able to define function prototypes draw pictures of the runtime stack during execution of code (show understanding of memory model) state scope of any identifier in a C program, ie visibility, hiding Draw pictures of memory based on classes Explain reason for initialisation restrictions compile and run multi-file programs

45. define function prototypes draw pictures of the runtime stack during execution of code (show understanding of memory model) state scope of any identifier in a C program, ie visibility, hiding Draw pictures of memory based on classes Explain reason for initialisation restrictions compile and run multi-file programs

46. Memory: the picture so far Memory as a long stream of bits C code associates a name with a part of the memory – with space for that type Memory for different things: –Ordinary data –Arrays –Pointers Draw lines showing where pointers point to

47. Memory: the picture so far Memory as a long stream of bits C code associates a name with a part of the memory – with space for that type Memory for different things: –Ordinary data –Arrays –Pointers Draw lines showing where pointers point to chs[0] nump X_accurate chs[1] chs[2] chs[3]