In addition to name. Each variable in C program is characterized by its Type Scope Storage Class. Type Have already discussed

Size: px

Start display at page:

Download "In addition to name. Each variable in C program is characterized by its Type Scope Storage Class. Type Have already discussed"

Alyson Riley
5 years ago
Views:

1 Variables, Storage Class, Scope, Multiple File Multiple Module Projects Overview Will examine how variables characterized Will introduce and study variable s storage class Will examine a variable s visibility or scope Look at multiple file Multiple module projects Characterizing a Variable In addition to name Each variable in C program is characterized by its Type Scope Storage Class Type Have already discussed Scope Specifies a variables visibility within program Three primary Scopes Program or Global Local File Will discuss momentarily Storage Class Storage class determines a variable s Lifetime Location Storage Class Begin with storage class Storage Class Specifiers Five possible specifiers auto static register extern typedef - 1 of 20 -

2 Specifying variable s storage class Simple extension to Declaration and definition syntax storage-class-specifier type variable-name What do each of these mean Why are they used Examine each in turn Storage Class Specifier Will begin with storage class specifier auto Default storage class Appropriate to local variables Not necessary to specify Indicates variable s lifetime Automatically managed by system syntax auto type variable-name Scope Unlimited Persistence its lifetime Variable is Created Upon entering scope Entered onto stack Destroyed Upon leaving Access Limited to scope syntax auto type variable-name - 2 of 20 -

3 static syntax static type variable-name Scope Local to block Local to File Persistence Variable and value persist across invocations Initialized once At compile time Initialized to 0 by default Access Limited to scope Local to block Eternal file where declared Example staticvar0.c #include <stdio.h> #include <stdio.h> #define FALSE 0; #define TRUE 1; // specify the function prototype void myfunction (int value, int show); int main(void) int i, show = FALSE; for (i = 0; i< 3; i++) myfunction (i, show); show = TRUE; myfunction (0, show); - 3 of 20 -

4 return 0; void myfunction (int value, int show) static accessed = 0; if (show) printf ("Function accessed %i times\n", accessed); else accessed++; printf ("The value is %i \n", value); return; Simple program to count function accesses Function Counts accesses using static variable accessed myfunction() accessed initialized to 0 By default register Registers closest of all memory to CPU Using a speed metric Ideally would like to have All variables in registers Part of theory behind RISC architectures Large number of registers In CISC architecture Typically Can recommend to compiler Place certain variables into registers Tells compiler variable - 4 of 20 -

5 May be heavily used Allocate space in way to minimize access time Goal Faster and smaller programs Note: Only a recommendation Compiler may not follow Use for large number of variables may be counter productive Use with high optimizing compilers may have little effect Such compilers typically allocate variables as necessary syntax register type variable-name Scope Only local variables Function parameters Persistence Equivalent to auto Best place to use Tight loops Speed important Access Limited to scope extern Variables declared extern Provide first look at multi file programs External variables Give means of Declaring variable in one file Variable declared external to current file Using in another current file syntax extern type variable-name - 5 of 20 -

6 Scope N/A Persistence N/A Access N/A Does not allocate storage Tells compiler Variable defined elsewhere external to current file Memory to hold variable allocated outside current file Referenced in current context Expression in current file is A declaration not a definition Provides type information Compiler assumes space allocated elsewhere Example externalvarproj0 #include <stdio.h> // declaration and definition in second file: extern1.c // following declarations bring names into this file extern int i; extern int my[5]; int main(void) // The variable I is declared elsewhere i=3; // This line will print 3 printf ( The value of I is %i\n, i); // Three values are entered into the array my[] and printed for (i=0; i< 3; i++) my[i]=i; - 6 of 20 -

7 for (i=0; i< 3; i++) printf ("the value of my is %i\n", my[i]); return 0; // In second file extern1.c // Declare and define a couple of variables int i; int my[5]; Program will compile If try to execute without providing definitions i myarray[] will give error typedef Final storage class typedef Not actually new storage class Permits User to define synonyms for Existing type Provides New data type names Does not create new type Only creates new name For existing type Acts like alias for existing data type Simple Complex syntax typedef type synonym - 7 of 20 -

8 Scope In scope from time of definition Persistence N/A Access Limited to scope Similar to #define Merely preprocessor substitution Example typedef char * names[] Allows us to define names as synonym for array of pointers to chars Be careful with typedefs Can Redefine Obfuscate the language Use to Clarify Make more readable Scope Specifies a variables visibility within program Program Structure Describes how program organized Program One large main Multiple modules Functions Subroutines Multiple Files Compiled and Linked At same time At different times - 8 of 20 -

9 Question How is information and data shared among all different pieces Variables Can have same name in different modules How does compiler know about Variable Defined in one module Used in several others Look at old children s game Where s Waldo Can play variation Where s Clyde Example localvar0.c #include <stdio.h> void print1(void); void print2(float); int main(void) int clyde = 10; printf ("clyde is %i in main\n", clyde); print1(); return 0; void print1(void) // forces evaluation as a float rather than a double float clyde = 9.3f; printf("clyde is %3.2f in print1\n", clyde); print2(clyde); printf("clyde is now %3.2f in print1\n", clyde); return; void print2(float clyde) // forces evaluation as a float rather than a double - 9 of 20 -

10 clyde = 3.6f; printf("clyde is %3.2f in print2\n", clyde); return; Are these various uses legal If so How are they reconciled Let s begin simply Most questions relate to Scope of variable s name How widely within program Variable name is known C permits 3 primary scopes Program Global File Module Local Local Scope and Local Variables Local variables Defined Memory typically allocated on stack Known in a function Are not initialized to any value upon definition Unless provisions made Value exists on stack Only while in function body Goes away upon exit Does not persist across invocations Example Observe from above Value of clyde Local to each of 3 functions main print1-10 of 20 -

11 print2 Change to clyde in print2 Does not affect value in print1 Function prototypes Declared outside main Scope of functions Global with respect to the program Block Local Variables Variables may also be declared Local to a block Variable name Visible within the block Hidden outside Such capability Makes program more readable Easier to maintain Example localvars1.c #include <stdio.h> int main() int clyde = 10; int i; // This clyde is global to main for (i=0; i< 2; i++) float clyde = 3.14f; // This clyde is local to this block printf ("clyde is %3.2f in the first block\n", clyde); for (i=0; i< 2; i++) char clyde = 'c'; // This clyde is local to this block printf ("clyde is %c in the second block\n", clyde); printf ("clyde is %i outside either block\n", clyde); return 0; - 11 of 20 -

12 Global Scope and Global Variables Before beginning discussion of global variables Must state position Should only be used with Extreme Care Parsimony Global Variables Visible Point of declaration Until end of file Means any function in program Can access Generally if can access then will As program evolves Short term As developed Long term As used As modified Problem Functions may change Value that others depend upon Value Initialized to 0 by default Unlike local variables Example globalvars0.c #include <stdio.h> // function prototypes void incrementcount(void); void showcount(void); int count; int main() incrementcount(); showcount(); return 0; // count will be global - 12 of 20 -

13 void incrementcount() count += 4; return; // add 4 to the global variable count void showcount() printf ("The value of count is is:\n %i\n", count); return; File Scope File Scope Variables Examine variables who s scope is limited to file in which declared Are occasions Want variables external So can be shared Restrict access Prevent changes Inadvertent Unauthorized Use external static storage Provides means To share Yet hide syntax static type variable-name Names will not conflict with Same names In other files of same program - 13 of 20 -

14 Functions Usually visible to entire program If declared static Invisible outside of file where declared syntax static type function-name(.) Local Have seen that static local variables Persist across function invocations Such variables Invisible outside of function Example externalvarproj1 #include <stdio.h> int main() extern int i; extern int my[]; extern additem(); extern removeitem(); int number; i=3; // This line will print 3 printf ("The value of i is %i\n", i); // Three values are entered into the array my[] for (i=0; i< 3; i++) my[i]=i; // The function additem is called to add 3 to the variable count - 14 of 20 -

15 for (i=0; i< 3; i++) number = additem(); // The function removeitem is called to remove 2 from the variable count for (i=0; i< 2; i++) number = removeitem(); // Attempting to access the variable count results in a compile error //printf ("The number of items remaining is: %i\n", count); printf ("The value of number is: %i\n", number); return 0; // File containing externally declared variables and functions extern3.c int i; int my[10]; int additem(void); int removeitem(void); // count will be invisible outside of this file static int count; int additem() count += 1; return count; int removeitem() count -= 1; return count; - 15 of 20 -

16 Example illustrates External variables Variable hiding using static variables Observe Main file No size for the array needed No prototypes for functions used Accessing count Will give compiler error Second File Variables i, my[] Declared Static Variable count declared static scope limited to file Functions specified additem() removeitem() Multiple Module Multiple File Projects For small designs Putting all code into single module or file reasonable Often working with Larger designs Teams with multiple people Subcontracted work As result would like to be able to split design into smaller pieces Partitioning designs into Smaller cohesive modules Collecting modules into organized files Good design practice and not difficult - 16 of 20 -

17 Goals of such a process Each module should solve one well defined piece of the problem Design should be partitioned so that function of each module is easy to understand Partitioning should be done so that connections between modules only introduced because of connection between pieces of problem Partitioning should assure that connections between modules are as independent as possible Related modules should be collected in each file When decomposing into modules Begin with outside view of inter module relationships Such relationships called coupling Choosing how to decompose important Coupling Analysis of coupling examines interdependence between modules Objective Minimize coupling Want to make modules as independent as possible Reducing coupling means Reducing complexity of module interconnections Low coupling between modules Indicates well partitioned system Cohesion Idea related to coupling is cohesion Coupling addresses partitioning a system Cohesion addresses bringing things together We stress modularity and encapsulation Cohesion is measure of strength of functional relatedness Elements in a module Goal Create strong highly cohesive modules Whose elements are genuinely and strongly related to one another Conversely Elements should not be strongly related to elements in another module Want to maximize cohesion and minimize coupling - 17 of 20 -

18 Multiple Files Organizing project into multiple files good design practice Things to think about What modules to put in each file Variable scope Which variables /identifiers local to file File scope variables / identifiers not normally visible outside of file Which variables /identifiers to be shared Such variables /identifiers must be made visible to other files Which header files may be used in multiple files Why we never put definitions in header file Remember each file is translation unit Translation units individually compiled Modules Modules comprising each file C source code modules Should be related Identifiers, Variables, and Scope As we ve learned Identifiers/variables declared and defined in one module Have file scope Can t be see outside of file Have memory allocated at time of definition Identifier/variable can only be defined one time If we wish to use identifiers/variables defined in one file in another Must inform compiler Definition exists elsewhere Location of allocated memory sorted out by linker Can inform compiler in two ways As studied earlier in file where identifier/variable not defined but needed For each such identifier/variable include line extern type myvariable; extern retruntype myfunction(parameters); Tells compiler identifier/variable defined elsewhere Let linker manage memory addresses Remember don t lie to compiler It gets crabby - 18 of 20 -

19 Include necessary information in header file Add header file to file where identifier/variable not defined but needed Individual Files High-level structure of each file These will all be C source files File name will be of form filename.c File name should be suggestive of file contents Individual files will comprise One or more header files One or more C source modules Header Files Header files will include as necessary System header files User written header files Because header file may be used in multiple files Never include any code that allocates memory Multiple allocations for same variable not allowed In large programs Header files incorporated as what is called include sandwich As noted Each file is translation unit Each translation unit individually compiled Each may need declarations from other files Remember declarations do not allocate memory To allow each translation unit to use declarations Not have duplicates For each file build include sandwich as follows #ifndef aname #define aname #include <anysystemfiles.h> #include anyuserfiles.h #endif - 19 of 20 -

20 On first usage aname will not be defined Necessary files will be included On final build files only included one Summary In this lesson we Learned how variables are characterized Introduced and studied variable s storage class Examined variable s visibility or scope Should now be comfortable with notion of scope Explored first steps to building multiple file multiple module programs - 20 of 20 -

Programming in C. main. Level 2. Level 2 Level 2. Level 3 Level 3

Programming in C. main. Level 2. Level 2 Level 2. Level 3 Level 3 Programming in C main Level 2 Level 2 Level 2 Level 3 Level 3 1 Programmer-Defined Functions Modularize with building blocks of programs Divide and Conquer Construct a program from smaller pieces or components