Functions, Scope, and The Free Store

1. Functions, Scope, and The Free Store • Functions • Functions must be declared by a function prototype before they are invoked, • return_type Function_name(type , type, …); // Strong type checking • The return_type: • A function that does not return a value should declare a return_type of void. • A return statement is not necessary in a function with a void return type (however, • it can still be used to terminate the function), void Fun(){ if(cond) return; ….} • The default return_type is int (e.g., in function main(), return 0; is found) • Neither an array or a function can be specified as a return_type, • int[10] fun(); // Error. • The Argument_list: • Functions are allocated storage on a structure called the program’s run-time stack, • this stack is automatically popped when the function terminates. • Arguments are passed by-value (the entire object is copied), or by-reference (only • the address of the argument is copied) • Arrays are passed by reference using a pointer to the zeroth element of the array • Arguments can have default values, and functions can be overloaded

2. Functions, Scope, and The Free Store • Default Values for the Argument_list • A function may specify default values for all or only a subset of its arguments, • int fun(int i= 0);// a function prototype with a default argument initializer • int fun(int i = 0){//fun body….} // Error, a default value must be specified • only once in a file, by convention it should be in the declaration • The right most argument must have a default value before any argument to its left, • fun(int i= 0, double x); // Error, default order is incorrect • fun1(double x, int i= 0, char* str); // Error, the right most is not initialized • fun1(double x, int i=0; char* str= “No Free Lunch”); // OK • the invocation fun1(0.05, , “Hello”); // gives syntax error • Function Overloading • Several functions can be given the same name provided that each have a unique • Argument_list, e.g. the following functions can exist in the same file, • int max(int ,int); // returns the max of two integers • int max(const int * , int); // the first argument is a pointer • int max(const List &); // returns the max of a List type object • Avoid Ambiguous overloading: max(const int, int); // ambiguous with max(int,int) • print(unsigned int); print (int); // suppose we have the invocation print(100);

3. Functions, Scope, and The Free Store Identifier Scoping and Storage Classes The scope of identifiers has three types, 1. File Scope: identifier is declared in the file and not within a class or within a function 2. Local scope: identifiers are declared within a function 3. Class scope: identifiers are declared within a class For example, enum Boolean {false,true}; // Boolean has a file scope class X{ // X has a file scope Boolean fun(); // fun has a class scope } const int Max = 100; // Max has a file scope X x_obj; // x_obj has a file scope main(){ Boolean Quit; // Quit has a local scope int fun();// fun has local scope} Boolean X::fun(){…} int fun(){…..}// now fun has the file scope // the above is not function overloading

4. Functions, Scope, and The Free Store • File Scope • The outer most scope which encloses both local scope and class scope • The scope extends from the point of declaration in the file to the end of the file • Storage classes static and extern are used to specify whether the same identifier • can be declared and used in other files, e.g., • in file x.cpp: extern const int Max = 100; // Max can be used in other files • static int Max_size=1000; // Max_size can not be used in other • // files, i.e., it does not have external linkage • in file y.cpp: extern const int Max; // this does not allocate storage for Max • // Max has already been defined in x.cpp • extern int Max_size; // Error Max_size has static file scope • Constants by default are static(i.e., no external linkage), while variables by default • are extern. • Class names can be used in other files but there are conditions or rules for that, • it is better to put the class declarations in a header file and include this file in different • files as shown in the lab. assignment examples • typedef, enum, and template names can not have external linkage

5. Functions, Scope, and The Free Store Local Scope consists of function scope and block scope function scope: extern const int Max; // global constant max defined and initialized in another file funny(){ int I = 100; // local variable const int Max = :: Max * I; // the scoping operator is used to //access the global Max to initialize the local Max } Block Scope: while(cond){ int I = 0; I = 500; // this I is local to the while block if (cond) {int I = 0; // this is a different I local to the if block} } Static local variables {static int I=0; // I retains its most recent values and stays alive until the // program terminates I++; } // I will contain the number of times this block is executed

6. Functions, Scope, and The Free Store The following code will not produce a syntax error but will produce a dangling pointer, a pointer that points to no object, int * sqr(int x) { int y; y = x*x; return &y; }// the data object y does not exist after the termination of this function main(){ int * p = sqr(100); // p is a dangling pointer // and is initialized to point to an object which has been destroyed } // the above will different if y is declared as a static storage class using static int y; // y will still exist even after sqr() terminates