C++ unit-1-part-12

Prepared By: Asst. Prof. Sejal Jadav
Unit-1
Principles of Object Oriented Programming Tokens,
expressions & Control Statements
(14 MARKS)
B.C.A & B.Sc.(IT) – 3
CS-13 C++ and Object Oriented
Programming

Functions in c++
• What is Function?
• Definition, Declaration & Call
• Declaration
• Way to define a function
• Formal & Actual Arguments
• Types of formal arguments
• Call by value, call by address and call by reference

What is Function?
• Function is block of code performing a unit
task.
• Function definition is block of code.
• Function is a way to achieve modularization.
(no. of small functions)

• Function are of two types : Library (predefined)
function and user –defined
• Predefined functions are
• declared in header files and
• defined in library files

Function Definition, Declaration & Call
#include<iostream>
using namespace std;
main()
{
void fun();
Cout<<“You are in main”;
fun();
}
void fun()
{
Cout<<“you are in fun”;
}
Function Definition
Function Call
Function Declaration
Declaration of cout & cin

Function Declaration [Function PROTOTYPE]
•Function Declaration is also known as Function
Prototype.
•Functions need to be declared before use (just
like variable).

•Function can be declared locally or globally.
•Function has a name, return type and
arguments.
Syntax:
•ReturnType functionName(argumentList);

Way to define a function
• No argument no return value
• With argument no return value
• No argument with return value
• With argument with return value

5
6
Formal & Actual Arguments
#include<iostream>
int sum(int,int);
main()
{
int a=5,b=6;
int s=sum(a,b);
Cout<<“Sum is :
“<<s;
}
int sum(int x, int y)
{
Return (x+y);
}
a
b
s
a & b are actual argument
Sum() memory
block
main()
memory
block
x & y are formal argument
5
6
11
x
y

Types of Formal Argument
• Formal arguments can be of three types
• Ordinary variables of any type
• Pointer variables
• Reference variables

• On the basis of arguments there are two types of
function are available in C++ language, they are;

• There are two ways to pass value or data to function
in C++ language which is given below;

1. Ordinary Variables of any type

2. Pointer variables

3. Call by reference

Call by reference
• When formal arguments are reference variables, it is
function call by reference.
• The call by reference method the called function
does not create its own copy rather it refers to
original value only by different name i.e. reference.

• When we pass arguments by reference, the formal
arguments int sum(int &x,int &y) in the called
function becomes aliases to the actual arguments in
the calling function.
• (actual arguments -> aliases -> formal arguments )
• It means that when the called function is working
with its own arguments, it is actually working on the
original data.

Inline function
Benefits of Function:
• Easy to read
• Easy to modify
• Avoids rewriting of same code
• Easy to debug
• Better memory utilization

Function saves memory
•Function in a memory is to save memory space.
which becomes appreciable when a function is
likely to be called many times.

Function is time consuming:
• However every time a function is called, it takes lot of
extra time in executing a series of instructions for
tasks such as jumping to the functions, saving
registers, pushing arguments into the stack and
returning to the calling function.

• So, when function is small it is worthless to spend so
much extra time in such tasks in cost of saving
comparatively small space.

Inline function
•To eliminate the cost of calls to small functions,
C++ proposes a new feature called inline
function.
•An inline function is a function that is expanded
in line when it is invoked.

•Inline is a request not a command.
•The benefit of speed of inline functions reduces
as the function grows in size.

•So the compiler may ignore the request in some
situations. Few of them:
• Function containing loops, switch, goto.
• Functions with recursion.
•Containing static variable.

Syntax:
inline<function header>
{
Function body
}

#include<iostream>
using namespace std;
inline void address();
main()
{
address();
}
void address()
{
cout<<endl<<"CCSIT";
cout<<endl<<"Junagadh";
}

Default Arguments in C++ Functions
• The default arguments are used when you provide no
arguments or only few arguments while calling a
function.
• The default arguments are used during compilation of
program.
• For example, lets say you have a user-defined function
sum declared like this: int sum(int a=10, int b=20),

• For example: int sum(int a=10, int b=20),
• now while calling this function you do not provide
any arguments, simply called sum(); then in this case
the result would be 30, compiler used the default
values 10 and 20 declared in function signature.
• If you pass only one argument like this: sum(80) then
the result would be 100, using the passed argument
80 as first value and 20 taken from the default
argument.

• Let’s look at example:01_defaultArg.Cpp

Rules of default arguments
• As you have seen in the above example that I have
assigned the default values for only two arguments b
and c during function declaration.
• It is up to you to assign default values to all
arguments or only selected arguments but remember
the following rule while assigning default values to
only some of the arguments:

• If you assign default value to an argument, the
subsequent arguments must have default values
assigned to them, else you will get compilation error.

• For example: Lets see some valid and invalid cases.
• Valid: Following function declarations are valid –
int sum(int a=10, int b=20, int c=30);
int sum(int a, int b=20, int c=30);
int sum(int a, int b, int c=30);

• Invalid: Following function declarations are invalid –
• Since a(a variable) has default value assigned, all the
arguments after a (in this case b and c) must have
default values assigned
int sum(int a=10, int b, int c=30);

• Since b has default value assigned, all the arguments
after b (in this case c) must have default values
assigned.
int sum(int a, int b=20, int c);

• Since a has default value assigned, all the arguments
after a (in this case b and c) must have default values
assigned, b has default value but c doesn't have, that’s
why this is also invalid
int sum(int a=10, int b=20, int c);

Const arguments
• The constant variable can be declared using
const keyword.
• The const keyword makes variable value stable.
• The constant variable should be initialized
while declaring.

• Syntax :
<function name> (const <type> <variable name>);
• The qualifier ‘const’ tells the compiler that the
function should not modify the argument.
• Let’s Look at example: DefaultArg.cpp

void add(const int a, int b)
{
a=a+b; //error
b=a+b;
cout<<“Sum = “<<b;
}
main()
{
add(2,5);
}
• In the above program, the prototype
of function add declared two
arguments.
• Out of two arguments the first
argument is a constant. The second
argument is not constant.
• When function add is invoked, the
first argument a is a const according
to prototype of function.
• Any attempt made to change the
value of variable a will cause an
error message “cannot modify a
constant variable.”

C++ unit-1-part-12

Recommended

Recommended

More Related Content

What's hot

What's hot (18)

Similar to C++ unit-1-part-12

Similar to C++ unit-1-part-12 (20)

More from Jadavsejal

More from Jadavsejal (20)

Recently uploaded

Recently uploaded (20)

C++ unit-1-part-12