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

The Function Definition 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 }

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

The Function Definition 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 }

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

The Function Definition 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 }

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

The Function Definition 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 }

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

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 );

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

Example #include <iostream.h> 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

Example #include <iostream.h> 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;

Example #include <iostream.h> 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;

Example #include <iostream.h> 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"; cout<<"\n the number is negative"; cout<<endl;

Example #include <iostream.h> 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;

Example #include <iostream.h> 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;

Example #include <iostream.h> 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;

Void Returned Data Type #include <iostream.h> 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

Example #include <iostream.h> 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() ; }

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);

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.

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.

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 ; }

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.

Difference between Function Definitions for Call 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. void func2 ( int & , int & ); // function prototype

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; }

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; }

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; }

Example 5: 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 ; }

Execution of Example 5 The user will be prompted to enter two integers. The user enters, for example, 10 and 20 that are saved in x and y respectively. When function add is called, the value of x and y are passed to the function. The function add takes the values 10 and 20 and links them to a and b respectively. The function will return the result which is 30. The output: Enter two integers: 10 20 x = 10 y = 20 The result is 30 After call x = 10 y = 20

Example 6: Call by Reference // File: calls2.cpp #include <iostream.h> // function prototype: the arguments to be passed by reference void duplicate (int & , int & , int & ); void main ( ) { int x, y , z ; // local variables in main cout << “ Enter three integers: “ ; cin >> x >> y >> z ; cout << “ Before call: “ << “ x = “ << x << “ y = “ << y << “ z = “ << z <<endl; duplicate ( x , y , z ) ; // calling duplicate function cout <<“ After call: << “ x = “ << x << “ y = “ << y << “ z = “ << z <<endl; } void duplicate ( int & a , int & b , int & c ) { a *= 2 ; b *= 2 ; c *= 2 ; }

Execution of Example 6 The user will be prompted to enter three integers. The user enters, for example, 10, 20, and 30 that are saved in x, y, and z respectively. When function duplicate is called, the addresses of x, y, and z are passed to the function. The addresses of x, y, and z are linked to the parameters of the function a, b, and c. The function will duplicate each parameter and save the result in the same parameter. Thus, a becomes 20 hence x becomes 20 also b becomes 40 hence x becomes 40 also c becomes 60 hence x becomes 60 also After the call we see that the values of x, y, and z are changed. The output: Enter three integers: 10 20 30 Before call: x = 10 y = 20 z = 30 After call: x = 20 y = 40 z = 60

Recursion Function call itself #include <iostream.h> int Fact (int N) { if (N<=1) return 1; else return N * Fact(N-1); } void main() { cout<<Fact(5)<<endl;

Example #include <iostream.h> int Zap (int N) { int Z; if (N<=1) Z=1; else Z= Zap(N-1) + Zap(N-3); return Z; } void main() { cout<<Zap(5)<<endl;

Array as parameter -Array name is pointer (call by reference) #include <iostream.h> void Increment (int a[]) { for (int i=0; i<5; i++) a[i] += 10; } void main() { int b[5] = {10,20,30,40,50}; Increment(b); for(int i=0; i<5; i++) cout<<b[i]<<'\t'; cout<<endl; }

Array as parameter -Array element (call by value) #include <iostream.h> void Increment (int a) { ++a; } void main() { int b[5] = {10,20,30,40,50}; Increment(b[1]); cout<<b[1]<<endl; }