Introduction Function Definition Void function Global Vs Local variables Random Number Generator Recursion Function Overloading Sample Code

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”

main(){ ----- ----- ----- ----- . . . ---- ----- -----Return 0;}

Bad Development Approach

•Easer To

DesignBuildDebugExtendModifyUnderstandReuseBetter Organization

Wise Development Approach

main(){ ----- ----}

function f1(){ --- ---}

function f2(){ --- ---}

In FORTRAN Modules Known as Subprograms In Pascal Modules known as Procedures &

Functions In C++ Modules Known as Functions & Classes Programs use new and “prepackaged” modules

New: programmer-defined functions and classes Prepackaged: from the standard library

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.

Main

Boss

Function A Function B Function Z

WorkerWorker

Function B2Function B1

Worker

Worker Worker Note: usual main( ) Calls other functions, but other functions

can call each other

Function Arguments can be:- Constant sqrt(9);- Variable sqrt(x);- Expression sqrt( x*9 + y) ;

sqrt( sqrt(x) ) ;

• Functions called by writingfunctionName (argument);orfunctionName(argument1, argument2, …);

• Examplecout << sqrt( 900.0 );

• sqrt (square root) function • The preceding statement would print 30• All functions in math library return a double

cout<< sqrt(9);

Function Name argument

3

Output

Parentheses used to enclose argument(s)

• 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

Method Description Example ceil( x ) rounds x to the smallest integer

not less than x ceil( 9.2 ) is 10.0 ceil( -9.8 ) is -9.0

cos( x ) trigonometric cosine of x (x in radians)

cos( 0.0 ) is 1.0

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 not greater than x

floor( 9.2 ) is 9.0 floor( -9.8 ) is -10.0

fmod( x, y ) remainder of x/y as a floating-point number

fmod( 13.657, 2.333 ) is 1.992

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 (x in radians)

sin( 0.0 ) is 0

sqrt( x ) square root of x sqrt( 900.0 ) is 30.0 sqrt( 9.0 ) is 3.0

tan( x ) trigonometric tangent of x (x in radians)

tan( 0.0 ) is 0

Fig. 3.2 Math library functions.

Math Library Functions Revisited

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

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

Syntax format for function definitionreturned-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)

Example functionint 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

// Creating and using a programmer-defined function.

#include <iostream.h>

int square( int ); // function prototype

int main()

{

// loop 10 times and calculate and output

// square of x each time

for ( int x = 1; x <= 10; x++ )

cout << square( x ) << " "; // function call

cout << endl;

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

} // end function square

Definition of square. y is a copy of the argument passed. Returns y * y, or y squared.

Function prototype: specifies data types of arguments and return values. square expects an int, and returns an int.

Parentheses () cause function to be called. When done, it returns the result.

1 4 9 16 25 36 49 64 81 100

#include<iostream.h>

int square(int); // prototypeint cube(int); // prototypemain(){ int i;

for (int i=1;i<=10;i++){

cout<< i<< “square=“ << square(i) << endl;cout<< i<< “cube=“ <<cube(i) << endl;

} // end forreturn 0;

} // end main functionint square(int y) //function definition{

return y*y; // returned Result}

int cube(int y) //function definition{

return y*y*y; // returned Result}

Output1 square=11 cube=12 square=42 cube=8....10 square=10010 cube=1000

} // end main

// function maximum definition. x, y and z are parameters

double maximum( double x, double y, double z )

{

double max = x; // assume x is largest

if ( y > max ) // if y is larger,

max = y; // assign y to max

if ( z > max ) // if z is larger,

max = z; // assign z to max

return max; // max is largest value

} // end function maximum

// Finding the maximum of three floating-point (real) numbers. #include <iostream.h>

double maximum( double, double, double ); // function prototype

int main()

{

double number1, number2;

double number3;

cout << "Enter three real numbers: ";

cin >> number1 >> number2 >> number3;

// number1, number2 and number3 are arguments to the maximum function call

cout << "Maximum is: "

<< maximum( number1, number2, number3 ) << endl;

return 0; // indicates successful termination

Enter three real numbers: 99.32 37.3 27.1928

Maximum is: 99.32

Enter three real numbers: 1.1 3.333 2.22

Maximum is: 3.333

Function maximum takes 3 arguments (all double) and returns a double.

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 prototypedouble maximum( double, double, double );

Definitiondouble maximum( double x, double y, double z )

{ …}

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;

}

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(){

funA();funB();return 0;

} void funA() {

cout << “Function-A takes no arquments\n”;}void funB(){

cout << “Also Function-B takes No arguments\n”;}

Will be the same in all cases

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

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 arguments2- Type of those arguments3-Order of those arguments

#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”;return 0;

}int add2(int x1,int y1){ int x; //local variables

x=44;cout << “\nLocal x=” << x << endl;return x1+y1;

}

global x=11global y=22Local x=4411+22=33---end of output---

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

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

}

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;

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

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)

#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 valuecout<< “x=“ << x << “After returning”cout<< “z=“ << z << “before calling squareRef”;squareRef(z); // call by referencecout<< “z=“ << z<< “After returning squareRef”return 0;

}int squareVal(int a){

return a*=a; // caller’s argument not modified}void squarRef(int &cRef){

cRef *= cRef; // caller’s argument modified}

x=2 before calling squareVal4x=2 after returningz=4 before calling squareRefz=16 after returning squareRef

rand function generates an integer between 0 and RAND-MAX(~32767) a symbolic constant defined in <stdlib.h>

You may use modulus operator (%) to generate numbers within a specifically range with rand.

//generate 10 random numbers open-rangeint x; for( int i=0; i<=10; i++){

x=rand();cout<<x<<“ “;

}

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//generate 10 integers between 0……..49int x; for( int i=0; i<10; i++){

x=rand()%50;cout<<x<<“ “;

}

//generate 10 integers between 5…15int x; for ( int i=1; i<=10; i++){

x= rand()%11 + 5;cout<<x<<“ “;

}- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//generate 100 number as simulation of rolling a dice

int x;for (int i=1; i<=100; i++){

x= rand%6 + 1;cout<<x<<“ “;

}

the rand( ) function will generate the same set of random numbers each time you run the program .

To force NEW set of random numbers with each new run use the randomizing process

Randomizing is accomplished with the standard library function srand(unsigned integer); which needs a header file <stdlib.h>

Explanation of signed and unsigned integers: int is stored in at least two-bytes of memory and can

have positive & negative values unsigned int also stored in at least two-bytes of

memory but it can have only positive values 0…..65535

#include<iostream.h>#include<iomanip.h>#include<stdlib.h>int main(){

int i;unsigned num;// we will enter a different number each time we runcin>>num;srand(num);for(i=1; i<=5; i++)

cout<<setw(10)<< 1+rand()%6;return 0;

}

Output for Multiple Runs

19 6 1 1 4 2 118 6 1 5 1 4 4 3 1 2 5 6 2 4 0 1 5 5 3 5 5 3 1 2 5 6 3 4

Different-set of Random numbers

#include<iostream.h>#include<iomanip.h>#include<stdlib.h>int main(){

int i;

for(i=1; i<=5; i++)cout<<setw(10)<< 1+rand()%6;

return 0;}

Output for Multiple Runs5 3 3 5 4 25 3 3 5 4 25 3 3 5 4 25 3 3 5 4 26 5 3 3 5 4

Same set of numbers for each run

Main calls another function…..normal A function calls another function2….normal A function calls itself ?! Possible?? YESA recursive function is one that call itself.

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

Thus the function launches (calls) a fresh copy of itself to work on the smaller problem –this is related as a Recursive-call/recursive step.

The function keeps dividing each new sub problem into two conceptual pieces until eventually terminates after converging on the base-case.

The function thus recognize the base-case and returns a result to the previous copy of the way up the line until original call of the function returns the final result to main.

5!

5*4!

4*3!

3*2!

2*1!

1

5!

5*4!

4*3!

3*2!

2*1!

1

Final value=120

1

2!=2*1=2 returned

3!=3*2=6 returned

4!=4*6=24 returned

5!=5*24=120 returned

//Recursive factorial Function#include<iostream.h>#include<iomonip.h>unsigned lion factorial(unsigned long);//prototypeint main(){

int num;cout<<“enter a positive integer:”;cin>>num;cout<<“factorial=“<<factorial(num);return 0;

}unsigned long factorial(unsigned long n){

if ( n <= 1) //the base casereturn 1;

elsereturn n * factorial (n - 1);

}

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