Functions12
- 1. C++ PROGRAMMING User-Defined Functions • Introduction • Function Definition • Void function • Global Vs Local variables • Random Number Generator • Recursion • Function Overloading • Sample Code
- 2. Functions in C++ • Experience has shown that the best way to develop and maintain large programs is to construct it from smaller pieces(Modules) • This technique Called “Divide and Conquer” Bad Development Approach Wise Development Approach main() main() •Easer To { { ----- ----- Design ---- ----- Build } ----- Debug ----- Extend function f1() . Modify { . Understand --- . Reuse --- ---- Better Organization } ----- ----- function f2() Return 0; { } --- --- }
- 3. (.Functions in C++(Cont • In FORTRAN Modules Known as Subprograms • In C++ Modules Known as Functions & Classes • Programs use new and “prepackaged” modules – New: programmer-defined functions and classes – Prepackaged: from the standard library
- 4. ++About Functions in C • Functions invoked by a function–call-statement which consist of it’s name and information it needs (arguments) • Boss To Worker Analogy A Boss (the calling/caller function) asks a worker (the called function) to perform a task and return result when it is done. Boss Main Worker Worker Worker Function Z Function A Function B Worker Worker Note: usual main( ) Calls other Function B1 Function B2 functions, but other functions can call each other
- 5. Function Calling • 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 • Function Arguments can be: - Constant sqrt(9); - Variable sqrt(x); - Expression sqrt( x*9 + y) ; sqrt( sqrt(x) ) ;
- 6. Function Calling • Calling/invoking a function – sqrt(x); – Parentheses an operator used to call function • Pass argument x • Function gets its own copy of arguments – After finished, passes back result Function Name argument Output 3 cout<< sqrt(9); Parentheses used to enclose argument(s)
- 7. Math Library Functions Revisited Method Description Example ceil( x ) rounds x to the smallest integer ceil( 9.2 ) is 10.0 not less than x ceil( -9.8 ) is -9.0 cos( x ) trigonometric cosine of x cos( 0.0 ) is 1.0 (x in radians) 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 floor( 9.2 ) is 9.0 not greater than x floor( -9.8 ) is -10.0 fmod( x, y ) remainder of x/y as a floating- fmod( 13.657, 2.333 ) is 1.992 point number 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 sin( 0.0 ) is 0 (x in radians) sqrt( x ) square root of x sqrt( 900.0 ) is 30.0 sqrt( 9.0 ) is 3.0 tan( x ) trigonometric tangent of x tan( 0.0 ) is 0 (x in radians) Fig. 3.2 Math library functions.
- 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 Definition • Function prototype – Tells compiler argument type and return type of function – int square( int ); • Function takes an int and returns an int – Explained in more detail later • 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 Definition • Syntax format for function definition returned-value-type function-name (parameter-list) { Declarations of local variables 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 Definition • 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
- 12. // Creating and using a programmer-defined function. #include <iostream.h> Function prototype: specifies int square( int ); // function prototype data types of arguments and return values. square int main() expects an int, and returns { an int. // loop 10 times and calculate and output // square of x each time for ( int x = 1; x <= 10; x++ ) cout << square( x ) << " "; // function call Parentheses () cause function to be called. cout << endl; When done, it returns the result. return 0; // indicates successful termination } // end main // square function definition returns square of an integer int square( int y ) // y is a copy of argument to function { return y * y; // returns square of y as an int Definition of square. y is a copy of the argument passed. } // end function square Returns y * y, or y squared. 1 4 9 16 25 36 49 64 81 100
- 13. 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 ) { … }
- 14. void Function takes arguments If the Function does not RETURN result, it is called void Function #include<iostream.h> void add2Nums(int,int); main() { int a, b; cout<<“enter tow Number:”; cin >>a >> b; add2Nums(a, b) return 0; } void add2Nums(int x, int y) { cout<< x<< “+” << y << “=“ << x+y; }
- 15. void Function take no arguments If the function Does Not Take Arguments specify this with EMPTY-LIST OR write void inside #include<iostream.h> void funA(); void funB(void) main() { Will be the same funA(); in all cases funB(); return 0; } void funA() { cout << “Function-A takes no arqumentsn”; } void funB() { cout << “Also Function-B takes No argumentsn”; }
- 16. Remarks on Functions • Local variables – Known only in the function in which they are defined – All variables declared inside a function are local variables • Parameters – Local variables passed to function when called (passing- parameters) • Variables defined outside and before function main: – Called global variables – Can be accessible and used anywhere in the entire program
- 17. Remarks on Functions • Omitting the type of returned result defaults to int, but omitting a non-integer type is a Syntax Error • If a Global variable defined again as a local variable in a function, then the Local-definition overrides the Global defining • Function prototype, function definition, and function call must be consistent in: 1- Number of arguments 2- Type of those arguments 3-Order of those arguments
- 18. Local vs Global Variables #include<iostream.h> int x,y; //Global Variables int add2(int, int); //prototype main() { int s; x = 11; y = 22; cout << “global x=” << x << endl; cout << “Global y=” << y << endl; s = add2(x, y); cout << x << “+” << y << “=“ << s; cout<<endl; cout<<“n---end of output---n”; global x=11 return 0; } global y=22 int add2(int x1,int y1) Local x=44 { int x; //local variables 11+22=33 x=44; ---end of output--- cout << “nLocal x=” << x << endl; return x1+y1; }
- 19. Finding Errors in Function Code int sum(int x, int y) { int result; result = x+y; } this function must return an integer value as indicated in the header definition (return result;) should be added ---------------------------------------------------------------------------------------- - int sum (int n) { if (n==0) return 0; else n+sum(n-1); } the result of n+sum(n-1) is not returned; sum returns an improper result, the else part should be written as:- else return n+sum(n-1);
- 20. Finding Errors in Function Code void f(float a); { float a; cout<<a<<endl; } ; found after function definition header. redefining the parameter a in the function void f(float a) { float a2 = a + 8.9; cout <<a2<<endl; }
- 21. Finding Errors in Function Code void product(void) { int a, b, c, result; cout << “enter three integers:”; cin >> a >> b >> c; result = a*b*c; cout << “Result is” << result; return result; } According to the definition it should not return a value , but in the block (body) it did & this is WRONG. Remove return Result;
- 22. Function Call Methods • Call by value • A copy of the value is passed • Call by reference • The caller passes the address of the value • Call by value Up to this point all the calls we have seen are call-by-value, a copy of the value (known) is passed from the caller-function to the called- function Any change to the copy does not affect the original value in the caller function Advantages, prevents side effect, resulting in reliable software
- 23. Function Call Methods • Call By Reference We introduce reference-parameter, to perform call by reference. The caller gives the called function the ability to directly access the caller’s value, and to modify it. A reference parameter is an alias for it’s corresponding argument, it is stated in c++ by “flow the parameter’s type” in the function prototype by an ampersand(&) also in the function definition-header. Advantage: performance issue void function_name (type &);// prototype main() { ----- ------ } void function_name(type ¶meter_name)
- 24. Example Function Call #include<iostream.h> int squareVal(int); //prototype call by value function void squareRef(int &); // prototype call by –reference function int main() { int x=2; z=4; cout<< “x=“ << x << “before calling squareVal”; cout << “n” << squareVal(x) << “n”; // call by value cout<< “x=“ << x << “After returning” cout<< “z=“ << z << “before calling squareRef”; squareRef(z); // call by reference cout<< “z=“ << z<< “After returning squareRef” return 0; x=2 before calling squareVal } 4 int squareVal(int a) x=2 after returning { z=4 before calling squareRef return a*=a; // caller’s argument not modified z=16 after returning squareRef } void squarRef(int &cRef) { cRef *= cRef; // caller’s argument modified }
- 25. Call-by-value vs. Call-by-reference So far we looked at functions that get a • copy of what thecaller. passed in This is call-by-value, as the value is what gets – .(passed in (the value of a variable We can also define functions that are • passed areference. to a variable This is call-by-reference, the function can – .change a callers variables directly
- 26. Recursion and Recursive Functions • Main calls another function…..normal • A function calls another function2….normal • A function calls itself ?! Possible?? YES A recursive function is one that call itself.
- 27. Concept Of recursion • A recursive function is called to solve a problem • The function knows to solve only the simplest cases or so-called base-cases • Thus if the function called with a base-case, it simply returns a result. But if it is called with more complex problem, the function divides the problem into two conceptual pieces, one knows how to do, and another doesn't know what to do. • The second case/piece must resemble the original problem, but be a slightly simpler/smaller version of the original problem
- 28. Function Overloading • Function overloading – Functions with same name and different parameters – Should perform similar tasks • I.e., function to square ints and function to square floats int square( int x) {return x * x;} float square(float x) { return x * x; } • A call-time c++ complier selects the proper function by examining the number, type and order of the parameters