View
232
Download
1
Category
Tags:
Preview:
Citation preview
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
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
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
• 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
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; ...
Do_Input( );Process_and_Print( );
}
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?
m1m2m3m4
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; ...}
Housekeeping data for Do_Input
i1i2
m1m2m3m4
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; ...}
m1m2m3m4
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; ...}
Housekeeping datafor
Process_and_Printp1p2
m1m2m3m4
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; ...}
Housekeeping data for calc
xyc1
Housekeeping datafor
Process_and_Printp1p2
m1m2m3m4
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; ...}
Housekeeping datafor
Process_and_Printp1p2
m1m2m3m4
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; ...}
m1m2m3m4
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; ...}
• 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
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
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
You need to distinguish these in drawings of memory models
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
You need to distinguish these in drawings of memory models
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
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
Initialisations - globalsInitialisations - globals
#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 */
...
}
• 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
Compiling multi-file programsCompiling multi-file programs
Preprocessor
C compiler
Assembler
Linker
Source codeName.c
Assembly codeName.s
Object codeName.o
a.out
Compiling multi-file programsCompiling 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
Compiling multi-file programsCompiling multi-file programs
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
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
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
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]
Recommended