part 3-functions
DESCRIPTION
TRANSCRIPT
• Introduction• Function Definition• Void function• Global Vs Local variables• Random Number Generator• Recursion• Function Overloading• Sample Code
C++ PROGRAMMING SKILLSPart 3
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 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.
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
compute square and cube of numbers [1..10] using functions
#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 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
¶meter_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
Function Call Example
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-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<<“ “;
}
Random Number Generator
• 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 valuesunsigned int also stored in at least two-bytes of
memory but it can have only positive values 0…..65535
Random Number Generator
#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;
}
Randomizing with srand
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;}
without srand
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
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!
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);
}
Finding Factorial Recursively
• 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