Lecture 10
More on Functions
Let’s see the last program from our last
lecture-
#include<stdio.h>
#include<conio.h>
int maximum(int,int,int); // function prototype
main(){
int x,y,z;
printf(“Enter
three integers: ”);
scanf(“%d
%d %d”,&x,&y,&z);
printf
(“The maximum is %d”,maximum(x,y,z));
}
//function definition
int maximum(int a,int b, int c){
int max=a;
if(b>max)
max=b;
if(c>max)
max=c;
return max;
}
The variables x, y and z are
called ‘actual arguments’, whereas the variables a, b and c are
called ‘formal arguments’. Any number of arguments can be passed to a function
being called. However, the type, order and number of the actual and formal
arguments must always be same.
Instead of using different variable names x,
y and z, we could have used the same variable names a, b
and c. But the compiler would still treat them as different
variables since they are in different functions.
There is no restriction on the number of return
statements that may be present in a function. Also, the return statement
need not always be present at the end of the called function. The following
program illustrates these facts.
All the following are valid return statements.
return ( a ) ;
return ( 23 ) ;
return ( 12.34 ) ;
return ;
In the last
statement a garbage value is returned to the calling function since we are not
returning any specific value. Note that in this case the parentheses after return
are dropped.
A function can return only one value at a
time. Thus, the following statements are invalid.
return ( a, b ) ;
return ( x, 12 ) ;
If the value of
a formal argument is changed in the called function, the corresponding change
does not take place in the calling function. For example,
The output of the above program would be:
60
30
Thus, even
though the value of b is changed in fun( ), the value of a in
main( ) remains unchanged. This means that when values are passed to a
called function the values present in actual arguments are not physically moved
to the formal arguments; just a photocopy of values in actual argument is made
into formal arguments.
Calling Conventions
Calling
convention indicates the order in which arguments are passed to a function when
a function call is encountered. There are two possibilities here:
- Arguments might be passed from left
to right.
- Arguments might be passed from right
to left.
C language
follows the second order.
Consider the
following function call:
fun (a, b, c, d ) ;
In this call it
doesn’t matter whether the arguments are passed from left to right or from
right to left. However, in some function call the order of passing arguments
becomes an important consideration. For example:
int a = 1 ;
printf ( "%d %d %d", a,
++a, a++ ) ;
It appears that
this printf( ) would output 1 2 2. This however is not the case. Surprisingly, it
outputs 3 3 1.
Scope Rules
The scope of an identifier is the portion
of the program in which an identifier is referenced. When we declare a local variable
in a block, it can be referenced only in that block or in blocks nested within
that block. The four scopes for an identifier are-
1. Function scope
2. File scope
3. Block scope
4. Function prototype scope
Labels are only
identifiers with function scope. Label is an identifier with name followed by a
colon. Often used with goto statement. Though, use of goto statements is
discouraged, we are taking a look at a program that uses goto and a label
The sample
output of the program is as follows-
An identifier
declared outside any function has file scope. Such an identifier is known to
all functions from the point it is declared until the end of the file. Global
variables, function definitions, function prototypes placed outside a function
all have file scope.
Identifiers
declared inside a block have block scope. Block scope ends at the terminating
right brace (}) of the block. Local variables declared at the beginning of a
function have block scope. Another example is function parameters. When blocks
are nested, and an identifier in an outer block has the same name as an
identifier in the inner block, the identifier in the outer block is hidden
until the inner block terminates.
Identifiers with
function prototype scope are those used in the parameter list of a function
prototype.
#include
<stdio.h>
#include
<conio.h>
void
a ();
void
b();
void
c();
int
x=1; // Global Variable
void
main(){
int x=5;
printf (“Local x in outer scope of main is
%d”, x);
{
int x=7;
printf (“Local x in inner scope of
main is %d”, x);
}
printf (“Local x in outer scope of main is
%d”, x);
a();
b();
c();
a();
b();
c();
printf (“Local x in main is %d”, x);
getch();
}
void
a(){
int x=25;
printf (“Local x in a after entering is
%d”,x);
x++;
printf (“Local x in a before exiting is
%d”,x);
}
void
b(){
static int x=50;
printf (“Local static x in b after
entering is %d”,x);
x++;
printf (“Local static x in b before exiting
is %d”,x);
}
void
c(){
printf (“Global x in c after entering is
%d”,x);
x++;
printf (“ Global x in c before exiting is
%d”,x);
}
The output of
the program is as follows-
Local x in outer scope of main is
5
Local x in inner scope of main is
7
Local x in outer scope of main is
5
Local x in a after entering is 25
Local x in a before exiting is 26
Local static x in b after entering
is 50
Local static x in b before exiting
is 51
Global x in c after entering is 1
Global x in c before exiting is 2
Local x in a after entering is 25
Local x in a before exiting is 26
Local static x in b after entering
is 51
Local static x in b before exiting
is 52
Global x in c after entering is 2
Global x in c before exiting is 3
Math Library Functions
Math library
functions allow the programmer to perform certain common mathematical
calculations. We will discuss many of these math library functions in this
lecture.
A programmer
desiring to calculate and print the square root of 900.0 can write-
printf(“%.2f”,
sqrt (900.0));
When the
statement is executed, sqrt() is called to calculate the square root of the
number contained in the parenthesis (900.0). The number 900.0 is the argument
of sqrt() function. The statement will print 30.00. sqrt() function takes an
argument of type double and returns a result of type double.
Note- All math library functions return the data type double.
printf(“%.2f”,
sqrt (c1+d*f));
If c1=13.0,
d=3.0 and f=4.0, then the line would print 5.00.
Some other
useful math library functions-
Function
|
Description
|
exp(x)
|
Exponential function
|
log(x)
|
Natural logarithm (base e)
|
log10(x)
|
Logarithm (base 10)
|
fabs(x)
|
Absolute value
|
ceil(x)
|
Rounds x to the smallest integer not less
than x
|
floor(x)
|
Rounds x to the largest integer not
greater than x
|
pow(x,y)
|
x to the power y
|
fmod(x,y)
|
Remainder of x/y as a floating point
number
|
sin(x)
|
Trigonometric sine of x
|
cos(x)
|
Trigonometric cosine of x
|
tan(x)
|
Trigonometric tangent of x
|
1 comments:
This is great blog! Keep it up. chemical wash
Post a Comment