1. Storage & Linkage: Effects on Scope Rudra Dutta CSC 230 - Spring 2007, Section 001

2. Copyright Rudra Dutta, NCSU, Spring, 20072 Main Ideas Storage – Variables all have to be stored some“where” Linkage – What parts of entities in a compilation unit (file) is accessible to others which are linked together Scope – At any point, what variables are visible and accessible? – Connected to the runtime issue of lifetime Each of the above creates categories – Unfortunately, there is some overlap between them – Need to think of memory to appreciate

3. Copyright Rudra Dutta, NCSU, Spring, 20073 Storage Where the memory is allocated Two keywords: – auto and register – auto is default However, even auto variables go on either – Stack, or – Heap Where do global variables go? – Programmer need not care – “On the stack, but never goes away” - process lifetime

4. Copyright Rudra Dutta, NCSU, Spring, 20074 Scope - Basics Global variables - outside all functions – Is accessible from all functions within compilation unit Local variable - within a function – Just after function begins - most usual place – Accesssible only inside function – Separate variable from any global by same name Variables can be local to a block – BUT not inside statement (C99 usage is exception) More specific variable always “hides” less specific Variables only visible AFTER definition Issue of multiple files - later (linkage)

5. Copyright Rudra Dutta, NCSU, Spring, 20075 Linkage What parts of one compilation unit can another see/use? – External and internal linkage Linker will link object code produced by compiler – Compiler leaves “hooks” or links for linker – All functions, all global variables visible from another compilation unit Clearly, not local variables BUT, compiler has to be able to compile current unit – Undefined functions are always assumed to exist “somewhere” Optimistic approach - “linker will find” Bad practice - should declare explicitly – Undefined variables are treated pessimistically Must declare explicitly, otherwise stops compiler Keyword extern allows variable declarations – extern int i; – “The variable i is a global variable, defined in some other place”

6. Copyright Rudra Dutta, NCSU, Spring, 20076 Funny Things 1. What happens? #include int i; int main() { i = 10; do_something(); printf ("%d\n", i); return (0); } #include int i; int do_something() { while (i-=1){ /* some code */ } return (0); } Consider what happens to the memory/storage

7. Copyright Rudra Dutta, NCSU, Spring, 20077 Funny Things 2. What happens? #include int i; int main() { i = 10; do_something(); printf ("%d\n", i); return (0); } #include extern int i; int do_something() { while (i-=1){ /* some code */ } return (0); } Consider what happens to the memory/storage

8. Copyright Rudra Dutta, NCSU, Spring, 20078 Funny Things 3. What happens? #include int i; int main() { i = 10; do_something(); printf ("%d\n", i); return (0); } #include int do_something() { while (i-=1){ /* some code */ } return (0); } Consider what happens to the memory/storage

9. Copyright Rudra Dutta, NCSU, Spring, 20079 Funny Things 4. What happens? #include extern int i; int main() { i = 10; do_something(); printf ("%d\n", i); return (0); } #include extern int i; int do_something() { while (i-=1){ /* some code */ } return (0); } Consider what happens to the memory/storage

10. Copyright Rudra Dutta, NCSU, Spring, 200710 Funny Things 5. What happens? Consider what happens to the memory/storage #include int i = 20; /* call this iG */ int main() { int i; /* call this iM */ i = 10; { int i; /* call this iB */ printf ("A: %d\n", i=50); } printf ("B: %d\n", i); do_something (); } int do_something () { printf ("C: %d\n", i); }

11. Copyright Rudra Dutta, NCSU, Spring, 200711 Funny Things 6. What happens? Consider what happens to the memory/storage #include int i = 20; /* call this iG */ int main() { int i; /* call this iM */ i = 10; { extern int i; /* call this iB */ printf ("A: %d\n", i=50); } printf ("B: %d\n", i); do_something (); } int do_something () { printf ("C: %d\n", i); }

12. Copyright Rudra Dutta, NCSU, Spring, 200712 Funny Things 7. What happens? #include int i = 20; /* call this iG */ int main() { extern int i; /* call this iM */ i = 10; { int i; /* call this iB */ printf ("A: %d\n", i=50); } printf ("B: %d\n", i); do_something (); } int do_something () { printf ("C: %d\n", i); } Consider what happens to the memory/storage

13. Copyright Rudra Dutta, NCSU, Spring, 200713 Funny Things 8. What happens? #include extern int i = 20; /* call this iG */ int main() { int i; /* call this iM */ i = 10; { int i; /* call this iB */ printf ("A: %d\n", i=50); } printf ("B: %d\n", i); do_something (); } int do_something () { printf ("C: %d\n", i); } Consider what happens to the memory/storage

14. Copyright Rudra Dutta, NCSU, Spring, 200714 Funny Things 9. What happens? #include int main() { i = 10; { int i; /* call this iB */ printf ("A: %d\n", i=50); } printf ("B: %d\n", i); do_something (); } int i; /* call this iG */ int do_something () { printf ("C: %d\n", i); } Consider what happens to the memory/storage extern int i;

15. Copyright Rudra Dutta, NCSU, Spring, 200715 Summary of External Variables Variable Definition – Global automatically has external linkage – Local automatically has internal linkage Variable Declaration – Use keyword extern – Finds global variable defined in another file – Or same file Before, or after Declared variable has scope – Determined by position of declaration inside compilation unit Can NOT use declaration to pull in local variables of another compilation unit – Cannot override scope int i; int j; do_thing() { int k; } extern int i;

16. Copyright Rudra Dutta, NCSU, Spring, 200716 Persistence of Storage Usually, scope (file) determines lifetime (process) All local variables have – Scope only within block e.g. function – Lifetime only while the block code e.g. function call is on the stack The keyword static creates persistent storage – Storage becomes like global - with process lifetime – BUT scope remains the same – Variables retain value between visits to block – Where is storage? Programmer need not know

17. Copyright Rudra Dutta, NCSU, Spring, 200717 Effect on Linkage static also changes linkage to internal – Local variables were internal to begin with – Global variables (external) are made internal to the file – An extern declaration from another file will fail to find it This also applies to functions – Can create functions that are private to a file

18. Copyright Rudra Dutta, NCSU, Spring, 200718 Initialization An initialization statement is a definition and an assignment statement combined Automatic initialization: – If only definition is present, – Global and static variables automatically initialized to zero – Local variables initialized to nothing in particular – Concept of garbage Initialization occurs only when variable (storage) is created – Therefore only once for static variables

19. Copyright Rudra Dutta, NCSU, Spring, 200719 Read: Section 1.10 Sections 4.3, 4.4, 4.6, 4.7, 4.9