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

C++ PROGRAMMING User-Defined Functions

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”

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

Bad Development Approach

•Easer To

DesignBuildDebugExtendModifyUnderstandReuseBetter Organization

Wise Development Approach

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

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

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

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

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.

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 Calling

• 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

Function Calling

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• 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

Function Definition

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)

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

// 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

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 )

{ …}

void Function takes arguments

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

void Function take no arguments

• 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

Remarks on Functions

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

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

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

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;

}

Finding Errors in Function Code

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;

Finding Errors in Function Code

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

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

Function Call Methods

#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

Example Function Call

Call-by-value vs. Call-by-reference

•So far we looked at functions that get a copy of what the caller passed in.

–This 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 a reference to a variable.

–This is call-by-reference, the function can change a callers variables directly.

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.

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

• 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

Function Overloading