Functions Chapter No. 5

Contents Simple functions Passing arguments to functions Reference arguments Default arguments const Function arguments Returning values from functions Overloaded functions Inline functions Recursion Scope and storage classes Returning by reference

Simple functions A function groups a number of program statements into a unit and gives it a name Conceptual organization of a program Reduce the program size A function is made when same work in a program is repeated for more than one time Function’s code is stored in only one place in memory

Function Components Component Purpose Example Declaration Specifies function name, argument type and return value. Alerts compiler (or programmer) that a function is coming up later Void func(); Call Causes the function to be executed Func() Definition The function itself. Contains the lines of code that constitute the function Void func() { //lines of code } Declarator First line of definition

Example #include<iostream.h> void starline (); Int main() { starline(); cout<<“Data type Range”<<endl; cout<<“char -128 to 127”<<endl; cout<<“short -32,768 to 32,767”<<endl; cout<<“int -2,147,483,648 to 2,147,483,6487”<<endl; return 0; } //----------------------------------------------------- void starline() for(int i=0; i<45; i++) cout<<‘*’; cout<<endl;

Passing arguments to function An argument is a piece of data, e.g. int value, passed from a program to the function Passing constants starline(char , int); //function declaration: must mention type of arguments to be passed later starline(‘=’, 45) //call to function ‘=’ and 45 passed as constant arguments starline(char ch, int n) // function declarator (variables hold the argument values are called parameters) { // function body for(int i=0; i<n;i++) cout<<ch; cout<<endl; }

Passing variables- by value void repchar(char, int); int main() { Char chin; Int nin; Cout<<“Enter a character: ”; cin>> chin; Cout<<“Enter number to time to repeat it: ”; cin>>nin; repchar(chin, nin); return 0; } //-------------------- void repchar(char ch, int n) for(int i= 0; i<n; i++) cout<<ch; repchar(chin, nin); in main() causes the values in these variables to be copied into parameters in repchar(ch, n)

Structure as arguments Struct Distance{ int feet; float inches}; // structure declaration Void engldisp(Distance); // function declaration //----------------------------------- Int main() { Distance d1; Cout<<“Enter feet”; cin>>d1.feet; Cout<<“Enter inches”; cin>>d1.inches; engldisp(d1); // function call return 0; } //-------------------------------------- Void engldisp(Distance dd) cout<<dd.feet<<“------”<<dd.inches;

Reference arguments A reference is an alias – different name – for a variable Instead a value is being passed to the function, a reference (memory address) to the original variable, in the calling program, is passed Reference arguments are indicated by the ampersand (&) sign following the data type e.g. float& intp The & indicates that intp is an alias – another name – for whatever variable is passed as an argument

Cont’d main() { int i = 10, j = 20; swapThemByVal(i, j); cout << i << " " << j << endl; // displays 10 20 swapThemByRef(i, j); cout << i << " " << j << endl; // displays 20 10 ... } void swapThemByVal(int num1, int num2) { int temp = num1; num1 = num2; num2 = temp; } void swapThemByRef(int& num1, int& num2)

Difference between pass by value and pass by reference swapThemByVal() at start swapThemByVal() after assignment Main() temp …. num1 10 num2 20 temp 10 num1 20 num2 i 10 j 20 temp …. num1 --- num2 swapThemByRef() i 10 j 20 temp 10 num1 --- num2 swapThemByRef(): After assignment i 20 j 10 Difference between pass by value and pass by reference

Default arguments A function can be called without specifying all its arguments It can be done when declaration must provide default values for those arguments Default arguments are useful when arguments have always same values Example Void repchar( char =‘*’, int = 45)// declaration with default args. ///////---call in main()---- Repchar(); Repchar(‘=’); Repchar(‘+’,30);

const Function Arguments Passing arguments by reference can modify a variable in calling program When you want to pass an argument by reference but not want to modify a variable, const modifier is used for this purpose A variable already defined as const in the calling program must be passed as const argument

Example Void aFunction(int&, const int& b); Int main() { Int alpha = 7; Int beta = 11; aFunction(alpha, beta); return 0; } Void aFunction(int& a, const int& b) a = 107; //OK b = 111; //error: can’t modify constant argument

Returning values from functions When a function completes its execution it can return a single value to the calling program A return is actually a answer to the problem that function has solved When a function returns a value the data type must be specified Data type is mentioned in function declaration part return statement is use to return value Multiple values can be returned using reference arguments and other is return a structure

Example int add(int a,int b); int main() { int num1,num2,result; cout << " Enter number1: " << num1<< endl; cin>>num1; cout<<“Enter number 2: ”<<endl; cin>>num2; result = add(num1,num2); cout << " The result is : " << result << endl; return 0; } int add(int a, int b) int add; add = a + b; return add; }

Overloaded Functions In C++ two different functions can have the same name if their parameter types or number are different Compiler decides which function to call, depends on number of parameters or types int operate (int a, int b) { return (a*b); } float operate (float a, float b) { return (a/b); } int main () { int x=5,y=2; float n=5.0,m=2.0; cout << operate (x,y); cout << "\n"; cout << operate (n,m); return 0; } Output 10 2.5

Inline functions Single copy of function is placed in memory Multiple calls are made from main program causes multiple jumps in memory which takes extra time for execution Inline function suggests compiler to place function code at each point the function is called The format for its declaration is: inline type name ( arguments ... ) { instructions ... }

Recursion Recursion involves a function calling itself long factorial (long a) { if (a > 1) return (a * factorial (a-1)); else return (1); } int main () long number; cout << "Please type a number: "; cin >> number; cout << “Factorial of ”<< number<<“is ”<< factorial (number); return 0;

Scope and Storage class Scope of a variable determines which part of program can access it. Two kinds Variables with local scope are visible only within block Variables with file scope are visible throughout a file Storage class determines how long it stays in existence Automatic: exist during lifetime of the function in which they are defined static : exist for the lifetime of the program

Cont’d Local Static local global Visibility Function File Lifetime Program program Initialized value Not initialized Storage Stack Heap Purpose Variables used by a single function Same as local, but retains value when function terminates Variables used by several functions

Returning by Reference Function that returns a reference is treated as if it were a variable. It returns alias to a variable There are two corollaries to this Can’t return a constant in setx() Can’t return a reference to local variable int x; int& setx() { return x; } int main() setx()=98; cout << "X: " << x<< endl; return 0;