block structure, scope and macros

Transcription

1 static variables static variables week 6, and macros Ritsumeikan University College of Information Science and Engineering Ian Piumarta 1 / 20

2 review of static variables static variables // declaration and definition returntype functionname ( void ) statement... // declaration only returntype functionname ( parametertype parametername,... ) ; int squaredint(int n) return n*n; // Return the length of STRING. // Assumes STRING is properly nul-terminated. size_t stringlength(char string[]) size_t len= 0; while (string[len]) ++len; return len; the body of the function is a compound statement also called a block of statements the entire block behaves like one statement Ian Piumarta 2 / 20

3 static variables static variables noun the opportunity or possibility to do or deal with something the of a variable is the region of the program in which we can do things with that variable if we can deal with the variable at a particular point, it is in if we cannot deal with it, it is out of variables (and their ) fall into two major categories: and Ian Piumarta 3 / 20

4 static variables static variables variables are declared inside a function or block they only exist inside the function or block where they are defined when a block ends, its variables cease to exist variables variable names must be unique within a given block, however... the same name can be re-declared inside a nested block the new declaration shadows the old one, making it temporarily inaccessible until the inner block ends and the shadowed name becomes visible again #include <stdio.h> int main() int a= 6, b= 9; printf("%d %d\n", a, b); // 6 9 int b= 42; // shadows outer b printf("%d %d\n", a, b); // 6 42 // outer b visible again printf("%d %d\n", a, b); // 6 9 printf("%d %d\n", a, b); // 6 9 int a; // shadows outer a printf("%d %d\n", a, b); //? 9 a= 54; printf("%d %d\n", a, b); // 54 9 // outer a visible again return 0; Ian Piumarta 4 / 20 06a

5 variables static variables static variables variables are those declared outside any function or block they exist everywhere (which is what means, after all) they can be used anywhere, as long as we know their type anywhere after their declaration is maybe a more pragmatic description #include <stdio.h> int g= 99; // variable void foo(void) printf("%d\n", g); 06b void bar(void) g += 1; printf("%d\n", g); int main() printf("%d\n", g); // 99 foo(); // 99 bar(); // 100 printf("%d\n", g); // 100 foo(); // 100 int g= 42; foo(); // 100 bar(); // 101 printf("%d\n", g); // 42 return 0; Ian Piumarta 5 / 20

6 static variables static variables variables are to the entire program a program can be made from (and libraries) a given variable (with a particular name) exists in all of them // file: main.c #include <stdio.h> int g= 42; // definition void printg(); // declaration int main() printg(); printf("%d\n", g); return 0; inc/06c1 // file: print.c #include <stdio.h> int g; variables // declaration void printg(void) // definition printf("%d\n", g); g= 666; printf("%d\n", g); inc/06c2 compiled separately then linked together $ cc -o main main.c print.c $./main there is only one variable called g; it is declared in both files (and initialised in at most one of them) the same variable everywhere (run this yourself, and try initialising g in both files or in neither of them) Ian Piumarta 6 / 20

7 static variables and static variables static variables what if we wanted each file to have its own different variable called g? there is a that is halfway between and, called file file- variables are within the file where they are declared they do not exist anywhere outside that file putting static in the declaration gives a variable (or function) file // file: main.c #include <stdio.h> static int g= 42; // file void printg(); int main() printg(); printf("%d\n", g); return 0; inc/06d1 // // file: print.c #include <stdio.h> static int g; // file inc/06d2 void printg(void) // printf("%d\n", g); g= 666; printf("%d\n", g); compiled separately then linked together $ cc -o main main.c print.c $./main assigning to g in print.c has no effect on g in main.c g in print.c is still uninitialised here, even though main.c has initialised its g the variables called g in the two files are completely independent of each other Ian Piumarta 7 / 20

8 static variables static variables static variables using static with variables has a different effect the lifetime of a variable is how long that variable exists during the lifetime of a variable, its value is preserved unless you assign a new value to it, obviously the of a variable and its lifetime are usually the same but there is no reason why this has to be the case Ian Piumarta 8 / 20

9 static variables static variables static variables variables declared static are in only in the block where they are declared do not cease to exist at the end of the block their lifetime is the same as a variable have the same value each time you (re)enter the function unless you assign a new value to it, obviously are initialised once, at the start of program execution just like a variable int nextint(void) declaration inside a block variable has static in declaration variable has lifetime static int counter= 10; // this initialisation happens only once return counter++; // counter is preserved between calls int main() printf("%d\n", nextint()); // 10 printf("%d\n", nextint()); // 11 printf("%d\n", nextint()); // 12 return 0; Ian Piumarta 9 / 20

10 static variables static variables behave like variables defined before the first statement (or declaration in the body) initialised by the actual arguments passed to the function void foo(int a, int b) // int a= 1; function behaves as if these definitions // int b= 2; are present and executed whenever... // a and b are already in- and initialised when the body is entered int c= a + b;... int main() foo(1, 2);... this function call is executed Ian Piumarta 10 / 20

11 initialisation static variables static variables int x= 42; // initialised at start, constant expression int foo(void) static int y= 999; // initialised at start, constant expression int z= x + y++; // initialised every time, any expression return z; // z destroyed here; y survives until next call variables and static variables initialisation happens at program start initialiser must be a constant expression (its value is computed at compile time) variables initialisation happens during program execution when control passes the point of declaration initialiser can be any expression (its value is computed at run time, and can use run time values) Ian Piumarta 11 / 20

12 static variables static variables parameters and variables are automatic they are created when a function or block begins they are destroyed when the function or block finishes recursive function calls have fresh, private copies of the automatic variables the values of those variables in other calls to the function are not affected static variables have lifetime they are created when the program starts running they are destroyed when the function or block finishes recursive function calls all see the same, shared copy of static variables the values of static variables can be used to communicate between calls Ian Piumarta 12 / 20

13 static variables static variables variable s are based on the positions of declarations in the program source is determined statically, by the structure of the source code it is independent of the flow of control during execution languages that have this property are called lexically (or statically) d program structure is represented by statements within blocks blocks can be nested they group statements for control flow they control the of variables languages that have this property are called block-structured Ian Piumarta 13 / 20

14 of induction variable in for loops static variables static variables in this loop for (int i= 0; i < 10; ++i) printf("%d\n", i); the induction variable i is visible in the loop test, update and body its is limited to those parts of the loop after the end of the loop, i is destroyed this is another difference between for and while loops int i= 0; while (i < 10) printf("%d\n", i); ++i; // i == 10 is still in for (int i= 0; i < 10; ++i) printf("%d\n", i); // i is no longer in = int i; for (i= 0; i < 10; ++i) printf("%d\n", i); // i == 10 is still in Ian Piumarta 14 / 20

15 static variables static variables stdio.h and similar are they often contain declarations for and variables the #include directive reads the contents of the file into your program as if you had typed the entire file contents at the point the #include appears after including a header file, the and variables it declares can be used you can write your own e.g., to share declarations between separate source files of the same program to include them in your program, use quote characters instead of angle brackets #include <stdio.h> #include "my-declarations.h" // system header file // personal header file system are searched for in standard locations personal are searched for in the same directory as your C source files Ian Piumarta 15 / 20

16 static variables static variables before your C program is compiled, it is pre-processed the C pre-processor performs text-to-text transformations on the source file the #include directive is not part of the C language it is a pre-processor directive your program is modified by inserting the contents of the header file in place of the #include directive once is complete, the result is finally fed to the compiler to see the results of, you can run just on your source file my-program.c: main file begins #include "my-header.h" main file ends my-header.h: header file begins declarations and other stuff go here header file ends $ cc -P -E my-program.c # -E show pre-processor output, -P turn off line numbers main file begins header file begins declarations and other stuff go here header file ends main file ends Ian Piumarta 16 / 20

17 : static variables static variables a macro is a named fragment of program text #define PI name replacement text whenever you write the name of the macro, the replacement text is substituted e.g: you write float circumference = 2.0 * PI * radius; and converts it into float circumference = 2.0 * * radius; before sending it to the compiler Ian Piumarta 17 / 20

18 : static variables static variables the replacement text can be anything you like #define RADIUS_TO_CIRCUMFERENCE 2.0 * PI * float circumference = RADIUS_TO_CIRCUMFERENCE radius; you can even do very silly things with macros #define then #define begin #define end // empty replacement if (a < b) then begin printf("a is less than b\n"); end (to make your C look like pseudo-code) but you probably shouldn t Ian Piumarta 18 / 20

19 : static variables static variables macros can take arguments, just like do except that there are no types involved you write #define MIN(A, B) ((A) <= (B)? (A) : (B)) smaller= MIN(first, second); and produces smaller= ((first) <= (second)? (first) : (second)); beware: side effects in macro arguments can have unexpected consequences you write smaller= MIN(x++, y++); and produces smaller= ((x++) <= (y++)? (x++) : (y++)); and you wonder why one of x or y is being incremented one too many times Ian Piumarta 19 / 20

20 developing with macros use macros for named constants, particularly strings and numbers static variables static variables use macros to avoid repetition code is shorter, more readable, more reliable (because repetition is avoided) step 1: invent a name for some action or computation you need more than once int a, b, c, d;... int minab= MIN(a, b); // need to find min of a and b here int mincd= MIN(c, d); // need to find min of c and d here step 2: implement the computation, without using a macro int minab= a <= b? a : b; int mincd= c <= d? c : d; // identical except for a and b // identical except for c and d step 3: identify the differences (these will be macro arguments) step 4: write a parameterised macro that implements the pattern #define MIN(X, Y) (X) <= (Y)? (X) : (Y) step 5: replace the implementations with the macro; test that it works int minab= MIN(a, b); int mincd= MIN(c, d); Ian Piumarta 20 / 20