Published on

Published in: Technology, Education
  • Be the first to comment

  • Be the first to like this

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide


  1. 1. C++ PROGRAMMING User-Defined Functions• Introduction• Function Definition• Void function• Global Vs Local variables• Random Number Generator• Recursion• Function Overloading• Sample Code
  2. 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. 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. 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 WorkerWorker Worker Function ZFunction A Function B Worker Worker Note: usual main( ) Calls other Function B1 Function B2 functions, but other functions can call each other
  5. 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. 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. 7. Math Library Functions RevisitedMethod Description Exampleceil( x ) rounds x to the smallest integer ceil( 9.2 ) is 10.0 not less than x ceil( -9.8 ) is -9.0cos( 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.38906fabs( x ) absolute value of x fabs( 5.1 ) is 5.1 fabs( 0.0 ) is 0.0 fabs( -8.76 ) is 8.76floor( x ) rounds x to the largest integer floor( 9.2 ) is 9.0 not greater than x floor( -9.8 ) is -10.0fmod( x, y ) remainder of x/y as a floating- fmod( 13.657, 2.333 ) is 1.992 point numberlog( x ) natural logarithm of x (base e) log( 2.718282 ) is 1.0 log( 7.389056 ) is 2.0log10( x ) logarithm of x (base 10) log10( 10.0 ) is 1.0 log10( 100.0 ) is 2.0pow( x, y ) x raised to power y (xy) pow( 2, 7 ) is 128 pow( 9, .5 ) is 3sin( 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.0tan( x ) trigonometric tangent of x tan( 0.0 ) is 0 (x in radians)Fig. 3.2 Math library functions.
  8. 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. 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. 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. 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. 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. 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. 14. void Function takes argumentsIf 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. 15. void Function take no argumentsIf 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. 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. 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. 18. Local vs Global Variables#include<iostream.h>int x,y; //Global Variablesint add2(int, int); //prototypemain(){ 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=22int 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. 19. Finding Errors in Function Codeint 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. 20. Finding Errors in Function Codevoid f(float a);{ float a; cout<<a<<endl;}; found after function definition header. redefining the parameter a in the functionvoid f(float a){ float a2 = a + 8.9; cout <<a2<<endl;}
  21. 21. Finding Errors in Function Codevoid 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. 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. 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 &parameter_name)
  24. 24. Example Function Call#include<iostream.h>int squareVal(int); //prototype call by value functionvoid squareRef(int &); // prototype call by –reference functionint 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} 4int 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. 25. Call-by-value vs. Call-by-reference So far we looked at functions that get a • copy of what thecaller. passed inThis 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. 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. 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 doesnt 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. 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