Functions and scope

Functions and scopeFunctions and scope

ConfidenceConfidence

In scopeIn scope

Reference:

K&K textbook, Chapter 4

PostconditionsPostconditionsYou 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

• define function prototypes• draw pictures of the runtime stack during




Function prototypesFunction prototypes

/*-------------------------------*/do_that( ) {

double *p; ...p = do_this(*p);

}/*-------------------------------*/double *do_this(double a) {

double *p; ...p = do_that( );

}

double *do_this(double);/*-------------------------------*/do_that( ) {

double *p; ...p = do_this(*p);

}/*-------------------------------*/double *do_this(double a) {

double *p; ...p = do_that( );

}

Function prototype





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; ...}

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; ...


}

Order of function executionOrder of function executionmain

Do_Input

Process_and_Print

calc

• Static v dynamic structure

• Order of functions does not affect runtime structure

Scope, static v dynamic structureScope, 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?

Terminology: scope….Terminology: scope….

• Scope = Visibility

• Visible v hidden

m1m2m3m4

main ( ){int m1, m2, m3, m4; ...


}Do_Input( ){


int p1, p2; ...calc(p1, p2);


int c1; ...}

Housekeeping data for Do_Input

i1i2

m1m2m3m4

main ( ){int m1, m2, m3, m4; ...


}Do_Input( ){


int p1, p2; ...calc(p1, p2);


int c1; ...}

m1m2m3m4

main ( ){int m1, m2, m3, m4; ...


}Do_Input( ){


int p1, p2; ...calc(p1, p2);


int c1; ...}

Housekeeping datafor

Process_and_Printp1p2

m1m2m3m4

main ( ){int m1, m2, m3, m4; ...


}Do_Input( ){


int p1, p2; ...calc(p1, p2);


int c1; ...}

Housekeeping data for calc

xyc1



m1m2m3m4

main ( ){int m1, m2, m3, m4; ...


}Do_Input( ){


int p1, p2; ...calc(p1, p2);


int c1; ...}



m1m2m3m4

main ( ){int m1, m2, m3, m4; ...


}Do_Input( ){


int p1, p2; ...calc(p1, p2);


int c1; ...}

m1m2m3m4

main ( ){int m1, m2, m3, m4; ...


}Do_Input( ){


int p1, p2; ...calc(p1, p2);


int c1; ...}





Communication between functions

• Arguments (aka parameters)

• Global data

• Which is better?

ScopeScope

• Within blocks

• Within a file

• Between files

Static structure of programs

Typical program structureglobal declarations

main function

other functions and global declarations interspersed

Note: need function prototypes before the function is used

Static structure of functions

Function headerDeclarationsFunction body

int Dojob(int age){

int jam;… statements of the function body

}

Static structure of blocks

Declarations

Block body

while ….

{int jam;

… statements of the block body

}

{/* outer block */ int a; int b; ...

{ /* inner block */ char a; int d; ... } ...}

Scope of variable identifiers

outera b

innera d

int main( ){ int a2; ...}

fileA

float a3;

char A(char a4){ char a5; ...}

functionsvariablesa1 a2 a3 a4 a5int a1; main A

Scope between files

• Importing variable identifiers

extern int a1;

• Hiding variable and function identifiers

static

Scope between files

• See example on page 75, Chapter 4 of textbook

ExerciseExercise• 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();

Storage classesStorage classes

• auto (stack)

• static

• register (optimisation - obsolete)

• extern

You need to distinguish these in drawings of memory models

Storage classesStorage classes

• stack

• global/static


Storage classes – memory models 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


Initialisations - globalsInitialisations - globals

#define BOUND 100static int a = 72 * sizeof(int);

int b = BOUND;

extern char x;

int y;

Volatile storage Persistent storageregister auto heap extern, static


#define BOUND 100static int a = 72 * sizeof(int);

int b = BOUND;

extern char x;

int y;

Volatile storage Persistent storageregister auto heap extern, static


#define BOUND 100static int a = 72 * sizeof(int); /* constant

expression */

int b = BOUND; /* constant expression */

extern char x; /* cannot be initialised here */

int y; /* defaults to zero */

Initialisations - localInitialisations - local

#define BOUND 100static 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;

...

}

Initialisations - localInitialisations - 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 */

...

}





Compiling multi-file programsCompiling multi-file programs

Preprocessor

C compiler

Assembler

Linker

Source codeName.c

Assembly codeName.s

Object codeName.o

a.out


• 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


bash$ gcc -c doin.c proc.c dout.cbash$ gcc doin.o proc.o dout.o –o pdsbash$ gcc -c proc.cbash$ gcc doin.o proc.o dout.o -o pds

Using functions from the standard libraries

#include <math.h>

double sin(double);double n;double x;

scanf("%f", &n);x = sin(n);

__________________________________

gcc -lm ...

Library name is ‘m’

PostconditionsPostconditionsYou should be able to• define function prototypes• draw pictures of the runtime stack during








Memory: the picture so farMemory: 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

Memory: the picture so farMemory: 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 tochs[0] nump

X_accuratechs[1]

chs[2]

chs[3]

Documents

Functions and scope