Sie sind auf Seite 1von 37

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 functioncall-statement which consist of
its 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
Me tho d De sc rip tio n Exa m p le
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 M a th lib ra ry func tio ns.
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 functions 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
{
// loop 10 times and calculate and output
an int.
// square of x each time
for ( int x = 1; x <= 10; x++ )
cout << square( x ) << " "; // function call

cout << endl;


Parentheses () cause function to be called.
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

#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;
}
void Function take no arguments
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()
{ Will be the same
funA(); in all cases
funB();
return 0;
}
void funA()
{
cout << Function-A takes no arquments\n;
}
void funB()
{
cout << Also Function-B takes No arguments\n;
}
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
#include<iostream.h>
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);
Finding Errors in Function Code
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;
}
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;
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 callers value, and to
modify it.
A reference parameter is an alias for its corresponding argument, it is stated in
c++ by flow the parameters 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
#include<iostream.h>
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
int squareVal(int a) 4
{ x=2 after returning
return a*=a; // callers argument not modified
z=4 before calling squareRef
z=16 after returning squareRef
}
void squarRef(int &cRef)
{
cRef *= cRef; // callers 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<< ;
}
Random Number Generator
//generate 10 integers between 515
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<< ;
}
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 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<iostream.h>
#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<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 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<iostream.h>
#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