Part 3-functions

C++ PROGRAMMING SKILLS
Part 3
User-Defined Functions
• Introduction
• Function Definition
• Void function
• Global Vs Local variables
• Random Number Generator
• Recursion
• Function Overloading
• Sample Code

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”
Bad Development Approach Wise Development Approach

main()
main() •Easer To {
{ -----
----- Design ----
----- Build }
----- Debug
----- Extend function f1()
. Modify {
. Understand ---
. Reuse ---
---- Better Organization }
-----
----- function f2()
Return 0; {
} ---
---
}

.)Functions in C++(Cont
• 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

++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.
Boss
Main

Worker
Worker Worker
Function Z
Function A Function B

Worker Worker
Note: usual main( ) Calls other
Function B1 Function B2 functions, but other functions
can call each other

Function Calling
• Functions called by writing
functionName (argument);
or
functionName(argument1, argument2, …);
• Example
cout << sqrt( 900.0 );
• sqrt (square root) function
• The preceding statement would print 30
• All functions in math library return a double
• Function Arguments can be:
- Constant sqrt(9);
- Variable sqrt(x);
- Expression sqrt( x*9 + y) ;
sqrt( sqrt(x) ) ;

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

Function Name argument Output
3
cout<< sqrt(9);

Parentheses used to enclose argument(s)

Math Library Functions Revisited
Method Description Example
ceil( x ) rounds x to the smallest integer ceil( 9.2 ) is 10.0
not less than x ceil( -9.8 ) is -9.0
cos( x ) trigonometric cosine of x cos( 0.0 ) is 1.0
(x in radians)
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 floor( 9.2 ) is 9.0
not greater than x floor( -9.8 ) is -10.0
fmod( x, y ) remainder of x/y as a floating- fmod( 13.657, 2.333 ) is 1.992
point number
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 sin( 0.0 ) is 0
(x in radians)
sqrt( x ) square root of x sqrt( 900.0 ) is 30.0
sqrt( 9.0 ) is 3.0
tan( x ) trigonometric tangent of x tan( 0.0 ) is 0
(x in radians)
Fig. 3.2 Math library functions.

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 Definition
• 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
• 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>
Function prototype: specifies
int square( int ); // function prototype data types of arguments and
return values. square
int main()
expects an int, and returns
{
an int.
// loop 10 times and calculate and output
// square of x each time
for ( int x = 1; x <= 10; x++ )
cout << square( x ) << " "; // function call

Parentheses () cause function to be called.
cout << endl;
When done, it returns the result.
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
Definition of square. y is a
copy of the argument passed.
} // end function square Returns y * y, or y squared.

1 4 9 16 25 36 49 64 81 100

compute square and cube of numbers [1..10] using functions
#include<iostream.h>

int square(int); // prototype Output
int cube(int); // prototype 1 square=1
main() 1 cube=1
{ int i; 2 square=4
2 cube=8
for (int i=1;i<=10;i++){ .
.
cout<< i<< “square=“ << square(i) << endl; .
cout<< i<< “cube=“ <<cube(i) << endl; .
} // end for 10 square=100
return 0; 10 cube=1000
} // end main function
int square(int y) //function definition
{
return y*y; // returned Result
}

int cube(int y) //function definition
{
return y*y*y; // returned Result
}

// 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; Function maximum takes 3
arguments (all double) and
cout << "Enter three real numbers: "; returns a double.
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

} // 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 Enter three real numbers: 99.32 37.3 27.1928
if ( y > max ) // if y is larger, Maximum is: 99.32
max = y; // assign y to max
Enter three real numbers: 1.1 3.333 2.22
if ( z > max ) // if z is larger,
Maximum is: 3.333
max = z; // assign z to max
return max; // max is largest value

} // end function maximum

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

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

void Function take no arguments
If the function Does Not Take Arguments specify this with EMPTY-LIST OR
write void inside
void funA();
void funB(void)
main()
{ Will be the same
funA(); in all cases
funB();
return 0;
}
void funA()
{
cout << “Function-A takes no arqumentsn”;
}
void funB()
{
cout << “Also Function-B takes No argumentsn”;
}

Remarks on Functions
• 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
• 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 arguments
2- Type of those arguments
3-Order of those arguments

Local vs Global Variables
int x,y; //Global Variables
int add2(int, int); //prototype
main()
{ 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”;
global x=11
return 0;
}
global y=22
int add2(int x1,int y1) Local x=44
{ int x; //local variables 11+22=33
x=44; ---end of output---
cout << “nLocal x=” << x << endl;
return x1+y1;
}

Finding Errors in Function Code
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 function
void 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;

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

Function Call Methods
• 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 Example
int squareVal(int); //prototype call by value function
void squareRef(int &); // prototype call by –reference function
int main()
{ int x=2; z=4;
cout<< “x=“ << x << “before calling squareVal”;
cout << “n” << squareVal(x) << “n”; // call by value
cout<< “x=“ << x << “After returning”
cout<< “z=“ << z << “before calling squareRef”;
squareRef(z); // call by reference
cout<< “z=“ << z<< “After returning squareRef”
return 0;
x=2 before calling squareVal
}
4
int squareVal(int a)
x=2 after returning
{
z=4 before calling squareRef
return a*=a; // caller’s argument not modified
z=16 after returning squareRef
}
void squarRef(int &cRef)
{
cRef *= cRef; // caller’s argument modified
}

Random Number Generator
• 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-range
int x;
for( int i=0; i<=10; i++){
x=rand();
cout<<x<<“ “;
}
-------------------------------------------------------
//generate 10 integers between 0……..49
int x;
for( int i=0; i<10; i++){
x=rand()%50;
cout<<x<<“ “;
}

//generate 10 integers between 5…15
int 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

Randomizing with srand
#include<iomanip.h>
#include<stdlib.h>
int main()
{
int i;
unsigned num;
// we will enter a different number each time we run
cin>>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 1
18 6 1 5 1 4 4 Different-set of Random
3 1 2 5 6 2 4 numbers
0 1 5 5 3 5 5
3 1 2 5 6 3 4

without srand
#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 Runs
5 3 3 5 4 2
5 3 3 5 4 2 Same set of numbers for
5 3 3 5 4 2
5 3 3 5 4 2
each run
6 5 3 3 5 4

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

.(Concept Of recursion (cont
• 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.

Finding Factorial Recursively
5! Final value=120
5!
5!=5*24=120 returned
5*4! 5*4!
4!=4*6=24 returned
4*3! 4*3!
3!=3*2=6 returned
3*2! 3*2!
2!=2*1=2 returned
2*1! 2*1!
1
1 1

Finding Factorial Recursively
//Recursive factorial Function
#include<iomonip.h>
unsigned lion factorial(unsigned long);//prototype
int 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 case
return 1;
else
return n * factorial (n - 1);
}

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

Part 3-functions

Recommended

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to Part 3-functions (20)

Recently uploaded (20)

Part 3-functions