Unit IV
(Contd…..)
The Concept of modularization and User defined
functions - Definition -
Multifunction Program, proto-types.
Multifunction Program, proto-types.
What is a Function
Function is a group of
statements that together perform a task. Every C program has at least one
function, which is main(), and all the most trivial programs can define
additional functions.
You can divide up your
code into separate functions. How you divide up your code among different functions
is up to you, but logically the division usually is so each function performs a
specific task.
A function is known
with various names like a method or a sub-routine or a procedure, etc.
A function
declaration tells the compiler about a function's name,
return type, and parameters.
A function definition
provides the actual body of the function.
When a program makes
a function call, the program control is transferred to the
called function. A called function performs a defined task and
when its return statement is executed or when its function-ending closing
brace is reached, it returns the program control back to the main program.
The C standard library provides numerous
built-in functions that your program can call. Eg:-printf(),
scnf(),etc.,
Facts about functions
in C
(a)
C program is a collection of one or more
functions.
(b) A
function gets called when the function name is followed by a semicolon. For example,
main( )
{
function1( ) ;
}
which one or more statements may be
present. For example,
function1( )
{
statement 1 ;
statement 2 ;
statement 3 ;
}
(d) Any
function can be called from any other function. Even main( ) can be
called from other functions. For example,
main( )
{
message( ) ;
}
message( )
{
printf ( "\nCan't imagine
life without C" ) ;
main( ) ;
}
(e)
A function can be called any number of times.
For example,
main( )
{
message( ) ;
message( ) ;
}
message( )
{
printf ( "\nJewel
Thief!!" ) ;
}
(f)
The order in which the functions are defined in
a program and the order in which they get called need not necessarily be same.
For example,
main( )
{
message1( ) ;
message2( ) ;
}
message2( )
{
printf ( "\nBut the butter was
bitter" ) ;
}
message1( )
{
printf ( "\nMary bought some
butter" ) ;
}
Here, even though message1(
) is getting called before message2( ), still, message1( ) has
been defined after message2( ). However, it is advisable to define the
functions in the same order in which they are called. This makes the program
easier to understand.
(g)
A function can call itself. Such a process is
called ‘recursion’.
(h)
A function can be called from other function,
but a function cannot be defined in another function. Thus, the following
program code would be wrong, since argentina( ) is being defined inside
another function, main( ).
main( )
{
printf ( "\nI am in
main" ) ;
argentina( )
{
printf ( "\nI am in
argentina" ) ;
}
}
(i)
There are basically two types of functions:
·
Library functions Ex. printf( ), scanf(
) etc.
·
User-defined functions Ex. argentina( ), brazil(
) etc.
As the name suggests,
library functions are nothing but commonly required functions grouped together
and stored in what is called a Library. This library of functions is present on
the disk and is written for us by people who write compilers for us. Almost
always a compiler comes with a library of standard functions. The procedure of
calling both types of functions is exactly same.
Why Use Functions
(a) Writing functions avoids rewriting the
same code over and over.
(b) If the operation of a program can be
divided into separate activities, and
each activity
placed in a different function, then each could be written
and checked more or less independently.
Separating the code into
modular functions also makes the program
easier to design and
understand.
Defining
a Function
The general form of a function definition in C programming
language is as follows:
return_type function_name( parameter list )
{
body of the function
}
A function definition in C programming language consists of a function
header and a function body. Here are all the parts of a function:
·
Return Type: A
function may return a value. The return_type is the data type of the
value the function returns. Some functions perform the desired operations
without returning a value. In this case, the return_type is the keyword void.
·
Function Name: This
is the actual name of the function. The function name and the parameter list
together constitute the function signature.
·
Parameters: A parameter is like a placeholder. When a function is
invoked, you pass a value to the parameter. This value is referred to as actual
parameter or argument. The parameter list refers to the type, order, and
number of the parameters of a function. Parameters are optional; that is, a
function may contain no parameters.
·
Function Body: The
function body contains a collection of statements that define what the function
does.
Example:
Following is the source
code for a function called max(). This function takes two parameters
num1 and num2 and returns the maximum between the two:
/* function returning the
max between two numbers */
int max(int num1, int num2)
{
/* local variable declaration */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
Function Declarations
A function declaration
tells the compiler about a function name and how to call the function. The
actual body of the function can be defined separately.
A function declaration
has the following parts:
return_type function_name(
parameter list );
For the above defined
function max(), following is the function declaration:
int max(int num1, int num2);
Parameter names are not
important in function declaration only their type is required, so following is
also valid declaration:
int max(int, int);
Function declaration is
required when you define a function in one source file and you call that
function in another file. In such case you should declare the function at the
top of the file calling the function.
Calling a Function
To use a function, you
will have to call that function to perform the defined task.
When a program calls a
function, program control is transferred to the called function. A called
function performs defined task, and when its return statement is executed or
when its function-ending closing brace is reached, it returns program control
back to the main program.
To call a function, you
simply need to pass the required parameters along with function name, and if
function returns a value, then you can store returned value.
For example:
#include <stdio.h>
/* function declaration */
int max(int num1, int num2);
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
int ret;
/* calling a function to get max value */
ret = max(a, b);
printf( "Max value is : %d\n", ret
);
return 0;
}
/* function returning the max between two
numbers */
int max(int num1, int num2)
{
/* local variable declaration */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
Here, the max()
function along with main() function and compiled the source code. While running
final executable, it would produce the following result:
Max
value is : 200
Function Arguments
If a function is to use
arguments, it must declare variables that accept the values of the arguments.
These variables are called the formal parameters of the function.
The formal parameters
behave like other local variables inside the function and are created upon
entry into the function and destroyed upon exit.
No comments:
Post a Comment