functions of C++

Name – Tarandeep Kaur
Section – N2
Roll No. – 115331

 Definition of functions
 Function calling
 Function definition
 Void function
 Remarks on function
 Local v/s Global variables
 Function call methods
 Concept of recursion
 Function overloading

 A function is a subprogram that acts on data
and often returns a value.

 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

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

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

 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

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

// 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 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
)
{
…
}

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

 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

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

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

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; // caller’s argument not modified
z=4 before calling squareRef
}
z=16 after returning squareRef
void squarRef(int &cRef)
{
cRef *= cRef; // caller’s argument modified
}

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

 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

functions of C++

Related slideshows

More Related Content

functions of C++