Lecture#6 functions in c++
- 1. EC-102 Computer System & Programming Instructor: Jahan Zeb Department of Computer Engineering (DCE) College of E&ME
- 2. Functions Divide and conquer – Construct a program from smaller pieces or components – Each piece more manageable than the original program
- 3. Program Components in C++ Modules: functions and classes Programs use new and “prepackaged” modules – New: programmer-defined functions, – Prepackaged: from the standard library Functions invoked by function call – Function name and information (arguments) it needs Function definitions – Only written once – Hidden from other functions
- 4. Program Components in C++ Boss to worker analogy – A boss (the calling function or caller) asks a worker (the called function) to perform a task and return (i.e., report back) the results when the task is done.
- 5. Math Library Functions Perform common mathematical calculations – Include the header file <cmath> Functions called by writing – functionName (argument); or – functionName(argument1, argument2, …); Example cout << sqrt( 900.0 ); – sqrt (square root) function The preceding statement would print 30 – All functions in math library return a double
- 6. Math Library Functions Function arguments can be – Constants • sqrt( 4 ); – Variables • sqrt( x ); – Expressions • sqrt( sqrt( x ) ) ; • sqrt( 3 - 6x );
- 7. Method Description Example ceil( x ) rounds x to the smallest integer not less than x ceil( 9.2 ) is 10.0 ceil( -9.8 ) is -9.0 cos( x ) trigonometric cosine of x (x in radians) cos( 0.0 ) is 1.0 exp( x ) exponential function ex exp( 1.0 ) is 2.71828 exp( 2.0 ) is 7.38906 fabs( x ) absolute value of x fabs( 5.1 ) is 5.1 fabs( 0.0 ) is 0.0 fabs( -8.76 ) is 8.76 floor( x ) rounds x to the largest integer not greater than x floor( 9.2 ) is 9.0 floor( -9.8 ) is -10.0 fmod( x, y ) remainder of x/y as a floating-point number fmod( 13.657, 2.333 ) is 1.992 log( x ) natural logarithm of x (base e) log( 2.718282 ) is 1.0 log( 7.389056 ) is 2.0 log10( x ) logarithm of x (base 10) log10( 10.0 ) is 1.0 log10( 100.0 ) is 2.0 pow( x, y ) x raised to power y (xy) pow( 2, 7 ) is 128 pow( 9, .5 ) is 3 sin( x ) trigonometric sine of x (x in radians) sin( 0.0 ) is 0 sqrt( x ) square root of x sqrt( 900.0 ) is 30.0 sqrt( 9.0 ) is 3.0 tan( x ) trigonometric tangent of x (x in radians) tan( 0.0 ) is 0
- 8. Functions Functions – Modularize a program – Software reusability • Call function multiple times Local variables – Known only in the function in which they are defined – All variables declared in function definitions are local variables Parameters – Local variables passed to function when called – Provide outside information
- 9. Function Definitions Function prototype – Tells compiler argument type and return type of function – int square( int ); • Function takes an int and returns an int Calling/invoking a function – square(x); – Parentheses an operator used to call function • Pass argument x • Function gets its own copy of arguments – After finished, passes back result
- 10. Function Definitions Format for function definition return-value-type function-name( parameter-list ) { declarations and statements } – Parameter list • Comma separated list of arguments – Data type needed for each argument • If no arguments, use void or leave blank – Return-value-type • Data type of result returned (use void if nothing returned)
- 11. Function Definitions Example function int square( int y ) { return y * y; } return keyword – Returns data, and control goes to function’s caller • If no data to return, use return; – Function ends when reaches right brace • Control goes to caller Functions cannot be defined inside other functions Next: program examples
- 12. 1 2 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 int square( int ); // function prototype 9 10 int main() 11 { 12 // loop 10 times and calculate and output 13 // square of x each time 14 for ( int x = 1; x <= 10; x++ ) 15 cout << square( x ) << " "; // function call 16 17 cout << endl; 18 19 return 0; // indicates successful termination 20 21 } // end main 22 Parentheses () cause function to be called. When done, it returns the result. Function prototype: specifies data types of arguments and return values. square expects an int, and returns an int.
- 13. 23 // square function definition returns square of an integer 24 int square( int y ) // y is a copy of argument to function 25 { 26 return y * y; // returns square of y as an int 27 28 } // end function square 1 4 9 16 25 36 49 64 81 100 Definition of square. y is a copy of the argument passed. Returns y * y, or y squared.
- 14. 1 2 // Finding the maximum of three floating-point numbers. 3 #include <iostream> 4 5 using std::cout; 6 using std::cin; 7 using std::endl; 8 9 double maximum( double, double, double ); // function prototype 10 11 int main() 12 { 13 double number1; 14 double number2; 15 double number3; 16 17 cout << "Enter three floating-point numbers: "; 18 cin >> number1 >> number2 >> number3; 19 20 // number1, number2 and number3 are arguments to 21 // the maximum function call 22 cout << "Maximum is: " 23 << maximum( number1, number2, number3 ) << endl; 24 25 return 0; // indicates successful termination Function maximum takes 3 arguments (all double) and returns a double.
- 15. 26 27 } // end main 28 29 // function maximum definition; 30 // x, y and z are parameters 31 double maximum( double x, double y, double z ) 32 { 33 double max = x; // assume x is largest 34 35 if ( y > max ) // if y is larger, 36 max = y; // assign y to max 37 38 if ( z > max ) // if z is larger, 39 max = z; // assign z to max 40 41 return max; // max is largest value 42 43 } // end function maximum Enter three floating-point numbers: 99.32 37.3 27.1928 Maximum is: 99.32 Enter three floating-point numbers: 1.1 3.333 2.22 Maximum is: 3.333 Enter three floating-point numbers: 27.9 14.31 88.99 Maximum is: 88.99 Comma separated list for multiple parameters.
- 16. Function Prototypes Function prototype contains – Function name – Parameters (number and data type) – Return type (void if returns nothing) – Only needed if function definition after function call Prototype must match function definition – Function prototype double maximum( double, double, double ); – Definition double maximum( double x, double y, double z ) { … }
- 17. Function Prototypes Function signature – Part of prototype with name and parameters • double maximum( double, double, double ); Argument Coercion – Force arguments to be of proper type • Converting int (4) to double (4.0) cout << sqrt(4) – Conversion rules • Arguments usually converted automatically • Changing from double to int can truncate data – 3.4 to 3 Function signature
- 18. break and continue Statements break statement – Immediate exit from while, for, do/while, switch – Program continues with first statement after structure Common uses – Escape early from a loop – Skip the remainder of switch
- 19. 1 2 // Using the break statement in a for structure. 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 // function main begins program execution 9 int main() 10 { 11 12 int x; // x declared here so it can be used after the loop 13 14 // loop 10 times 15 for ( x = 1; x <= 10; x++ ) { 16 17 // if x is 5, terminate loop 18 if ( x == 5 ) 19 break; // break loop only if x is 5 20 21 cout << x << " "; // display value of x 22 23 } // end for 24 25 cout << "nBroke out of loop when x became " << x << endl; Exits for structure when break executed.
- 20. 26 27 return 0; // indicate successful termination 28 29 } // end function main 1 2 3 4 Broke out of loop when x became 5
- 21. break and continue Statements continue statement – Used in while, for, do/while – Skips remainder of loop body – Proceeds with next iteration of loop while and do/while structure – Loop-continuation test evaluated immediately after the continue statement for structure – Increment expression executed – Next, loop-continuation test evaluated
- 22. 1 2 // Using the continue statement in a for structure. 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 // function main begins program execution 9 int main() 10 { 11 // loop 10 times 12 for ( int x = 1; x <= 10; x++ ) { 13 14 // if x is 5, continue with next iteration of loop 15 if ( x == 5 ) 16 continue; // skip remaining code in loop body 17 18 cout << x << " "; // display value of x 19 20 } // end for structure 21 22 cout << "nUsed continue to skip printing the value 5" 23 << endl; 24 25 return 0; // indicate successful termination Skips to next iteration of the loop.
- 23. 26 27 } // end function main 1 2 3 4 6 7 8 9 10 Used continue to skip printing the value 5
- 24. 1 2 // Shifted, scaled integers produced by 1 + rand() % 6. 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 #include <iomanip> 9 10 using std::setw; 11 12 #include <cstdlib> // contains function prototype for rand 13 14 int main() 15 { 16 // loop 20 times 17 for ( int counter = 1; counter <= 20; counter++ ) { 18 19 // pick random number from 1 to 6 and output it 20 cout << setw( 10 ) << ( 1 + rand() % 6 ); 21 22 // if counter divisible by 5, begin new line of output 23 if ( counter % 5 == 0 ) 24 cout << endl; 25 26 } // end for structure Output of rand() scaled and shifted to be a number between 1 and 6.
- 25. 27 28 return 0; // indicates successful termination 29 30 } // end main 6 6 5 5 6 5 1 1 5 3 6 6 2 4 2 6 2 3 4 1
- 26. Storage Classes Variables have attributes – Have seen name, type, size, value – Storage class • How long variable exists in memory – Scope • Where variable can be referenced in program – Linkage • For multiple-file program
- 27. Storage Classes Automatic storage class – Variable created when program enters its block – Variable destroyed when program leaves block – Only local variables of functions can be automatic • Automatic by default • keyword auto explicitly declares automatic – register keyword • Hint to place variable in high-speed register • Good for often-used items (loop counters) • Often unnecessary, compiler optimizes – Specify either register or auto, not both • register int counter = 1;
- 28. Storage Classes Static storage class – Variables exist for entire program – May not be accessible, scope rules still apply (more later) static keyword – Local variables in function – Keeps value between function calls – Only known in own function extern keyword – Default for global variables/functions • Globals: defined outside of a function block – Known in any function that comes after it
- 29. Scope Rules Scope – Portion of program where identifier can be used File scope – Defined outside a function, known in all functions – Global variables, function definitions and prototypes Function scope – Can only be referenced inside defining function
- 30. Scope Rules Block scope – Begins at declaration, ends at right brace } • Can only be referenced in this range – Local variables, function parameters – static variables still have block scope • Storage duration does not affect scope Function-prototype scope – Parameter list of prototype – Names in prototype optional • Compiler ignores – In a single prototype, name can be used once
- 31. 1 2 // A scoping example. 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 void useLocal( void ); // function prototype 9 void useStaticLocal( void ); // function prototype 10 void useGlobal( void ); // function prototype 11 12 int x = 1; // global variable 13 14 int main() 15 { 16 int x = 5; // local variable to main 17 18 cout << "local x in main's outer scope is " << x << endl; 19 20 { // start new scope 21 22 int x = 7; 23 24 cout << "local x in main's inner scope is " << x << endl; 25 26 } // end new scope Declared outside of function; global variable with file scope. Local variable with function scope. Create a new block, giving x block scope. When the block ends, this x is destroyed.
- 32. 27 28 cout << "local x in main's outer scope is " << x << endl; 29 30 useLocal(); // useLocal has local x 31 useStaticLocal(); // useStaticLocal has static local x 32 useGlobal(); // useGlobal uses global x 33 useLocal(); // useLocal reinitializes its local x 34 useStaticLocal(); // static local x retains its prior value 35 useGlobal(); // global x also retains its value 36 37 cout << "nlocal x in main is " << x << endl; 38 39 return 0; // indicates successful termination 40 41 } // end main 42
- 33. 43 // useLocal reinitializes local variable x during each call 44 void useLocal( void ) 45 { 46 int x = 25; // initialized each time useLocal is called 47 48 cout << endl << "local x is " << x 49 << " on entering useLocal" << endl; 50 ++x; 51 cout << "local x is " << x 52 << " on exiting useLocal" << endl; 53 54 } // end function useLocal 55 Automatic variable (local variable of function). This is destroyed when the function exits, and reinitialized when the function begins.
- 34. 56 // useStaticLocal initializes static local variable x only the 57 // first time the function is called; value of x is saved 58 // between calls to this function 59 void useStaticLocal( void ) 60 { 61 // initialized only first time useStaticLocal is called 62 static int x = 50; 63 64 cout << endl << "local static x is " << x 65 << " on entering useStaticLocal" << endl; 66 ++x; 67 cout << "local static x is " << x 68 << " on exiting useStaticLocal" << endl; 69 70 } // end function useStaticLocal 71 Static local variable of function; it is initialized only once, and retains its value between function calls.
- 35. 72 // useGlobal modifies global variable x during each call 73 void useGlobal( void ) 74 { 75 cout << endl << "global x is " << x 76 << " on entering useGlobal" << endl; 77 x *= 10; 78 cout << "global x is " << x 79 << " on exiting useGlobal" << endl; 80 81 } // end function useGlobal local x in main's outer scope is 5 local x in main's inner scope is 7 local x in main's outer scope is 5 local x is 25 on entering useLocal local x is 26 on exiting useLocal local static x is 50 on entering useStaticLocal local static x is 51 on exiting useStaticLocal global x is 1 on entering useGlobal global x is 10 on exiting useGlobal This function does not declare any variables. It uses the global x declared in the beginning of the program.
- 36. local x is 25 on entering useLocal local x is 26 on exiting useLocal local static x is 51 on entering useStaticLocal local static x is 52 on exiting useStaticLocal global x is 10 on entering useGlobal global x is 100 on exiting useGlobal local x in main is 5
- 37. Functions with Empty Parameter Lists Empty parameter lists – void or leave parameter list empty – Indicates function takes no arguments – Function print takes no arguments and returns no value • void print(); • void print( void );
- 38. 1 2 // Functions that take no arguments. 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 void function1(); // function prototype 9 void function2( void ); // function prototype 10 11 int main() 12 { 13 function1(); // call function1 with no arguments 14 function2(); // call function2 with no arguments 15 16 return 0; // indicates successful termination 17 18 } // end main 19
- 39. 20 // function1 uses an empty parameter list to specify that 21 // the function receives no arguments 22 void function1() 23 { 24 cout << "function1 takes no arguments" << endl; 25 26 } // end function1 27 28 // function2 uses a void parameter list to specify that 29 // the function receives no arguments 30 void function2( void ) 31 { 32 cout << "function2 also takes no arguments" << endl; 33 34 } // end function2 function1 takes no arguments function2 also takes no arguments