Programming fundamentals 2 Chapter 1: Functions (Sub-Algorithms)

1. Programming fundamentals 2Chapter 1: Functions (Sub-Algorithms) Miss:Hanan Hardan

2. Contents • Algorithm Design • Sub-Algorithms • C++ Functions • Definition • Types of Functions • Examples • Function Prototype • Scope of Variables • Call by Value / Call by Reference

3. Top-Down Algorithm Design Topics to cover here: • Top-Down Design approach • Structured Programming • Sub-algorithms (a breadth look)

4. Top-Down Algorithm Design 1) Top-Down Design • The problem is divided into its major sub-problems • Solve the sub-problems to derive the solution to the original problem. 2) Structured Design: Dividing the problem into smaller sub-problems is called “structured design”, “top-down design”, “step-wise refinement”, and “modular Programming” 3) Structured Programming:The process of implementing a structured design is called “structured programming”

5. Structured Programming & Structure Chart The main goal of structured programming is • to write error-free code • to reuse any possible code that has already been written and tested (this is called reusability) • to have many sub-problems that are related.

6. Sub-algorithms • A sub-algorithm is a block of instructions that is executed when it is called from some other point of the algorithm. • The top-down algorithm design needs - to write the sub-algorithm definitions - to write an algorithm that calls the sub-algorithms (i.e. includes a CALL statement for each one) . • Sub-algorithms are of two type: - Sub-algorithms that do not return a value - Sub-algorithms that return a value * The sub-algorithm is calledfunctionin C++.

7. The Sub-algorithm Definition a) Definition of a sub-algorithm that does not return a value 1- Sub-algorithm without arguments: SUBALGORITHM subalgorithm-name ( ) Statements END subalgorithm-name where, ( ) is the empty list.

8. The Sub-algorithm Definition 2- Sub-algorithm with arguments: SUBALGORITHM subalgorithm-name (parameter-list) Statements END subalgorithm-name where, Parameter-list is a list that contains one or more parameters that are passed to the sub-algorithm.

9. The Call to a Sub-algorithm • The call to a sub-algorithm that does not return a value is given in the CALL statement which has the following syntax: subalgorithm-name (Actual parameters) Examples: draw_circle ( ) sum(4,7) sum(x,y)

10. The Call to a Sub-algorithm Interpretation of the sub-algorithm call Suppose that algorithm Figure calls the sub-algorithm draw_circle using the call statement CALL draw_circle ( ) Then the flow of control between sub-algorithms will be as follows (see the next diagram): • The flow of control in algorithm Figure stops on this statement to initiate the execution of the sub-algorithm draw_circle • after this sub-algorithm has finished executing, the next statement in the calling algorithm will be executed.

11. The Call to a Sub-algorithm Algorithm Figure Sub-algorithm draw_circle ALGORITHM Figure ------- ------- CALL draw_circle ( ) ------ ------ ------ END Figure SUBALGORITHM draw_circle ( ) ------ ------ ------ ------ END draw_circle call return

12. The Call to a function (C++) program Figure Function draw_circle void main(){ ------- ------- draw_circle ( ); ------ ------ ------ } call void draw_circle ( ) { ------ ------ ------ ------ } return

13. Example 1:

14. Example 2:

15. The Sub-algorithm Definition b) Definition of a sub-algorithm that returns a value: 1- Sub-algorithm without arguments: ftypeSUBALGORITHM subalgorithm-name () Statements END subalgorithm-name • Notes: - ftype: is any data type that the result of a subalgortihm can have. If the subalgorithm does not return any result, then no type is specified. -( ) empty list. -If the subalgorithm has a type, then the Statements in the body of the subalgorithm should have return statement, usually it is the last statement.

16. The Sub-algorithm Definition b) Definition of a sub-algorithm that returns a value: 2- Sub-algorithm without arguments: ftypeSUBALGORITHM subalgorithm-name (parameter-list) Statements END subalgorithm-name • Notes: - ftype: is any data type that the result of a subalgortihm can have. If the subalgorithm does not return any result, then no type is specified. - parameter-list: includes one or more arguments. -If the subalgorithm has a type, then the Statements in the body of the subalgorithm should have return statement, usually it is the last statement.

17. The Call to a Sub-algorithm • The call to a sub-algorithm that returns a value is given as follows: - The name of the sub-algorithm is given within the OUTPUT statement - The name of the sub-algorithm is given within the assignment statement Examples: result  Sum (x, y ) output Sum (x, y )

18. Example:

19. Example:

20. Function - Summary Function Definition: User defined function is a code segment (block) that perform an specific action. Function Syntax:Return_DTF_name ( list of formal parameters) { Action_ body ; }

21. Types of Functions Function are of 4 types: 1- A function that doesn’t return a value without argument -Return_DT is void -Action_body doesn’t contain return statement. Syntax: void function-name ( ) { local declarations // this is optional executable statements }

22. Example: function that doesn’t return a value without arguments void print_O ( ) { cout << “ ** “ << endl; cout << “ * * “ << endl; cout << “ * * “ << endl; cout << “ ** “ << endl; }

23. Types of Functions 2- A function that doesn’t return a value with arguments -Return_DT is void -Action_body doesn’t contain return statement. Syntax: void function-name(argument_list) { local declarations // this is optional executable statements }

24. Example: function that doesn’t return a value with arguments void print_box (int n) { cout << “* * * * * * *\n” ; cout << “* “ << n << “ * \n” ; cout << “* * * * * * *\n” ; }

25. Types of Functions 3- A function that returns a result of any type without arguments -Return_DT is any type -Action_body contains return statement. Syntax: <any type> function-name( ) { local declarations // this is optional executable statements }

26. Example: function that return a value without arguments int sum () { int x=5, y=7 ; return x+y ; }

27. Types of Functions 4- A function that returns a result of any type with arguments -Return_DT is any type -Action_body contains return statement. Syntax: <any type> function-name(argument_list ) { local declarations // this is optional executable statements }

28. Example: function that return a value with arguments int Rect_area (int L, int W) { int a ; a = L * W ; return a ; }

29. Calling (invoking) Function: a) The call to a Function that does not return a value is given in the following syntax: F_name (Actual parameters); e.g. draw_circle ( ); e.g. sum(4,7); b) The call to a Function that returns a value is given as follows: - The name of the functio is given within the output statement e.g cout<<sum(x,y); - The name of the Function is given within the assignment statement e.g. result = sum (x, y );

30. Example #include <iostream> using namespace std; int Max (int Value1, int Value2) { if (Value1 > Value2) return Value1; else return Value2; } void main() { int a, b; cout<<"\nPlease Enter the values of a and b: "; cin>>a>>b; cout<<"\n the maximum one is: "<<Max(a,b)<<endl; } Function Definition Calling the function in an expression like cout<<, condition, assignment statements

31. Example #include <iostream> using namespace std; int Max (int Value1, int Value2) { if (Value1 > Value2) return Value1; else return Value2; } void main() { int a, b, c; cout<<"\nPlease Enter the values of a and b: "; cin>>a>>b; c=Max(a,b); cout<<"\n the maximum one is: "<<c<<endl; }

32. Example #include <iostream> using namespace std; int Sum (int A, int B) { return (A+B); } void main() { int N1, N2, S; cout<<"\n Please Enter N1 and N2: "; cin>>N1>>N2; S = Sum(N1,N2); cout<<"\nSum= "<<S<<endl; }

33. Example #include <iostream> using namespace std; bool Positive (int Num) { if (Num > 0) return true; else return false; } void main() { int Number; cout<<"\nEnter Number: "; cin>> Number; if (Positive(Number)) cout<<"\n the number is positive"; else cout<<"\n the number is negative"; cout<<endl; }

34. Example #include <iostream> using namespace std; float Area (int R) { return (3.14 * R * R ); } void main() { int Radius; cout<<"Enter the Redius: "; cin>>Radius; cout<<"\nCircle Area is: "<<Area(Radius); cout<<endl; }

35. Example #include <iostream> using namespace std; long Power(int Base, int Exp) { int M=1; for(int i=1; i<=Exp; i++) M*=Base; return M; } void main() { int B, E; cout<<"\nEnter Base: "; cin>>B; cout<<"\nEnter Exponent: "; cin>>E; cout<<"\n Result= "<<Power(B,E); cout<<endl; }

36. Example #include <iostream> using namespace std; long Fact (int Num) { int F = 1, i = Num; while (i>=1){ F *= i; i--; } return F; } void main() { int Number; cout<<"Enter an integer number: "; cin>>Number; cout<<endl<<Number<<"!= "<<Fact(Number); cout<<endl; }

37. Example #include <iostream> using namespace std; void Print(char Ch, int n) { for (int i=1; i<=n; i++) cout<<Ch; cout<<endl; } void main() { char Sym; int Number; cout<<"\nEnter the Symbol: "; cin>>Sym; cout<<"\nHow many times: "; cin>>Number; Print(Sym,Number); } No Return Statement

38. Example #include <iostream> using namespace std; int Mul(int V1, int V2) { return V1 * V2; } void Result() { cout<<"\n5 x 9 = "<<Mul(5,9); cout<<"\n4 x 7 = "<<Mul(4,7); cout<<"\n6 x 4 = "<<Mul(6,4)<<endl; } void main() { Result() ; }

39. The Function Prototype • Like other identifiers in C++, function must be declared before it can be referenced. • To declare a function, we can insert a function prototype before the main function. • The function prototype provides all information that the C++ compiler needs to know to translate calls to the function correctly. • A function prototype tells the compiler the - data type of the function - the function name - information about the arguments that the function expects. • Examples: void draw_circle ( ); int m ( ) ; void print_box (int) ; int Rect_area (int , int);

40. Function Prototype #include <iostream.h> int Mul(int, int); int Add(int, int); void Show(); void main() { Show(); } int Mul(int X, int Y) { return X*Y; } int Add(int X, int Y) { return X+Y; } void Show() { int A=10, B=20; cout<<Add(A,B)<<'\t'<<Mul(A,B)<<endl; } Function Prototype contains only data types But may contain identifiers.

41. Scope of Variables (1) Global variables: - Those variables that are declared before the main function. - These are visible from any point of the code, inside and outside any function. (2) Local variables: - These are declared inside a block or a function. - The scope of local variables is limited to the same nesting level in which they are declared.

42. Example of Local and Global Variables // File: global.cpp #include <iostream.h> int x = 7 ; // global variables int fun1 (int ); // function prototype void main ( ) { int z ; // local variable in main cout << “The global variable: “ << x ; z = fun1 ( 5 ) ; // calling add function cout << “ The result is “ << z << endl ; } int fun1 ( int a ) { int r ; // local variable in fun1 r = a * a * a ; return r ; }

43. Example2 of Local and Global Variables #include <iostream> using namespace std; int x = 7; // global variable void main() { int x = 5; cout << "main "<< x<< endl; { int x = 3; cout << "in block "<< x<< endl; cout << "global "<< ::x<< endl; } } Output: main 5 in block 3 global 7

44. More about global and local variables • When you use the same variable name for both a local and a global variable, the local variable is used in a block or a function instead of the global variable, this operation is called “Masking”. • Each variable has a life time, which is the time this variable remains seen by the program. • The lifetime of a global variable extends through the execution of the whole program, while the lifetime of a local variable only last until the end of the function or the block where this local variable is defined.

45. Functions and Passing Parameters The mechanisms of passing parameters: (1) Call by value: - During the function call, the value of the argument is found and passed to the function. - Any modification inside the function does not affect the argument. (2) Call by reference: - During the function call, the address of the variable is passed to the function. - Any modification made on the parameter inside the function will have effect in the passed variable outside it.

46. Difference between Function Definitions forCall by Value and Call by Reference • For call by value, we declare the arguments of the function as usual. Example: int func1 ( int , int ); // function prototype • For call by reference, the type of the argument is followed by the symbol (&) to specify that the variable has to be passed by reference. Example: void func2 ( int & , int & ); // function prototype

47. Call by value When calling, the value of actual parameter will be copied to the formal parameter. #include <iostream.h> void Increment(int); void main() { int A = 10; Increment(A); cout<<A<<endl; } void Increment(int X) { ++X; }

48. Call By reference When calling, the reference formal parameter will be an alternative name to the actual parameter. #include <iostream.h> void Increment(int&); void main() { int A = 10; Increment(A); cout<<A<<endl; } void Increment(int &X) { ++X; }

49. Call By reference When calling, the pointer formal parameter will points to the actual parameter. #include <iostream.h> void Increment(int*); void main() { int A = 10; Increment(&A); cout<<A<<endl; } void Increment(int *X) { ++*X; }

50. Example 1: Call by Value // File: calls1.cpp #include <iostream.h> // function prototype: the arguments to be passed by value int add (int , int ); void main ( ) { int x, y , z ; // local variables in main cout << “ Enter two integers: “ ; cin >> x >> y ; cout << “ x = “ << x << “ y = “ << y << endl; z = add ( x , y ) ; // calling add function cout << “ The result is “ << z ; cout <<“After call “<< “ x = “ << x << “ y = “ << y << endl; } int add ( int a , int b ) { return a + b ; }