Sie sind auf Seite 1von 22

BCA I Year Semester I PROGRAMMING IN C

[BCA111]

Programming in C [BCA I Sem 2014]

Unit IV (1)

Unit IV

Functions - defining and accessing a function, function arguments, call by value, call by reference, calling functions with arrays, external, state and register variables, scope of variables, local and global variables, type conversion, block structure, recursion. =====================================================================

»» Introduction to Functions

A function is a block of code that performs a particular task. There are times

when we need to write a particular block of code for more than once in our

program. This may lead to bugs and irritation for the programmer.

C language provides an approach in which you need to declare and define a

group of statements once and that can be called and used whenever required.

This saves both time and space.

C functions can be classified into two categories, Library functions User-defined functions

Library functions are those functions which are defined by C library, example printf(), scanf(), strcat() etc. You just need to include appropriate header files to use these functions. These are already declared and defined in C libraries.

User-defined functions are those functions which are defined by the user at the time of writing program. Functions are made for code reusability and for saving time and space.

Advantage of function

o

It provides modularity to the program.

o

Easy code Reusability. You just have to call the function by its name to use it.

o

In case of large programs with thousands of code lines, debugging and editing becomes easier if you use functions

Declaration of function

return-type function-name (parameter-list);

A function declaration consists of 4 parts.

1 return-type

2 function name

3 parameter list

4 function statement

5 a return statement

Definition of function

return-type function-name (parameter-list)

{

function-body ; return statement;

}

Return type

Programming in C [BCA I Sem 2014]

Unit IV (2)

//This is function header

Return type specifies the type of value (int, float, char, double) that function is expected to return to the program calling the function.

Function name

Function name specifies the name of the function. The function name is any valid C identifier and therefore must follow the same rule of formation as other variables in C.

Parameter List

The parameter list declares the variables that will receive the data sent by calling program. They often referred to as formal parameters. These parameters are also used to send values to calling program.

Function Body

Programming in C [BCA I Sem 2014]

declarations and the

statement(algorithm) necessary for performing the required task. The body is enclosed within curly braces { }and consists of three parts.

The

function

body

contains

the

Unit IV (3)

o

Local variable declaration.

o

function statement that performs the tasks of the function.

o

a return statement that return the value evaluated by the function.

Functions and Arguments

Arguments are the values specified during the function call, for which the formal parameters are declared in the function.

The function can be categorized in three forms:-

o

The function with no arguments and no return.

o

The function with arguments but no return.

o

The function with arguments and return.

1. Function with no arguments and no return

Programming in C [BCA I Sem 2014]

Unit IV (4)

The function can be called (access, invoke, function calling) by writing its name and parenthesis.

function_name();

Whenever a function is called the control is transfer to the specified function the whole function is executed when the function is completed the control will be returned to calling points.

The function is declared once but the function can be used (called) as many times as required. The function can be called another function in program.

void print();

void main()

{

Statement1;

 

1

 

Statement2;

print();

print();  
 

Statement3;

 

Statement4;

2

 

}

   

void print()

{

3

Statement11;

 

Statement12;

printf("LMC”);

Statement13;

 

Statement14;

}

4

The function declaration order may be different than order of function calling means function can be called in any order.

2. Function with arguments and no return

Programming in C [BCA I Sem 2014]

Unit IV (5)

In this type of functions the information is send from calling points which is used within the function. The arguments at the calling point are called actual arguments and the arguments at the declaration are called formal arguments.

void add(int ,int);

void main()

{

Statement1;

Statement2;

add(2,4);

//actual argument

Statement3;

Statement4;

}

void print(int a,int b)

S//formal argument

{

 

Statement11;

Statement12;

printf("Add %d and %d is %d”,a,b,a+b);

Statement13;

Statement14;

}

When this type of function is called the function is transferred to functions header and also the value of actual argument is copied into the formal arguments then the execution of function is complied when function is complete its execution the control transfer back to its calling points.

Note:

1. The no of actual arguments must be equal to no of formal arguments.

2. The type of actual arguments should be same of formal arguments correspondingly.

Example fun(5, 6)

wrong

fun (5, 2.9, ’a’)

right

fun (j, k+2, ’+’)

right

3. Function with arguments and with return

Programming in C [BCA I Sem 2014]

Unit IV (6)

The type is the functions returns values type. If no type is mentioned then C compiler by default take it as integer type. The function of this type must have at lest one return statements. When function is accessed the control is transfer to function header. The values of actual parameter is transferred to formal parameters then whole function is executed when return statement is encountered within function than control is transferred back to calling point and the return value is placed at access point.

int add(int ,int);

void main()

{

Statement1;

Statement2;

tot = add(2,4);

//actual argument

Statement3;

Statement4;

}

int print(int a,int b)

{

 

Statement11;

Statement12;

c = a+b;

Statement13;

Statement14;

return c;

}

//formal argument

Note:

Programming in C [BCA I Sem 2014]

Unit IV (7)

o

Return value may be constant, variable or an expression

o

The return statements value must be same type of the functions types

o

The return statement without value can be used only in void type functions.

o

A single function may have one or more return statements. Whenever the return statement is executed the control is transferred back to calling point and the specified value is put there.

Programming in C [BCA I Sem 2014]

Unit IV (8)

»» Call by Value and Call by Reference

In C language “call by value” and “call by reference” (also known as pass-by- value and pass-by-reference). These methods are different ways of passing (or calling) data to functions.

Call by Value When we pass variable to function, it copies value of actual argument to formal argument.

Example

int add(int ,int);

void main()

{

int a,b; tot = add(a,b);

}

int print(int a,int b)

{

int c; c = a+b; return c;

}

Call by Reference

7 4 a b 7 4 a b
7
4
a
b
7 4
a b

a and b are

local to main

ACTUAL

VARIABLE

a and b are

local to print

FORMAL

VARIABLE

When we pass address of variable to function, it copies value of actual argument to formal argument.

Example

int add(int ,int);

void main()

{

int a,b; tot = add(&a,&b);

7 4 510 804 a b 510 804 *a *b
7
4
510
804
a
b
510
804
*a
*b

a and b are

local to main

ACTUAL

VARIABLE

}

int print(int *a,int *b)

{

int c; c = *a+*b; return c;

}

»» Passing array to functions

Programming in C [BCA I Sem 2014]

Unit IV (9)

*a and *b are local to print

a & b is pointer

FORMAL

VARIABLE

In C programming, a single array element or an entire array can be passed to a function. Also, both one-dimensional and multi-dimensional array can be passed to function as argument.

If you want to pass a single-dimension array as an argument in a function, you would have to declare function formal parameter in one of following two ways and both the declaration methods produce similar results because each tells the compiler that an integer pointer is going to be received. Similar way you can pass multi-dimensional array as formal parameters.

While passing arrays to the argument, the name of the array is passed as an argument (i.e. starting address of memory area is passed as argument).

Programming in C [BCA I Sem 2014]

Unit IV

(10)

Syntax

First

int search(int valsrc, int *);

//declaration

Second int search(int, int []);

//declaration

 

.

.

.

void main()

{

.

.

 

pos = search(tot,arr);

//call

 

.

}

First

 

void search(int valsrc, int *ap)

//definition

{

 

.

.

.

}

Second void search(int valsrc, int ap[])

{

 

.

.

.

}

Example

#include <stdio.h>

/* function declaration */ double getAverage(int arr[], int size);

arr 4 2 5 1 8 6 500 500 static pointer 500
arr
4
2
5
1
8
6
500
500
static pointer
500

ap

Programming in C [BCA I Sem 2014]

Unit IV

(11)

{

 

/* an int array with 5 elements */ int balance[5] = {1000, 2, 3, 17, 50}; double avg;

/* pass pointer to the array as an argument */ avg = getAverage( balance, 5 ) ;

/* output the returned value */ printf( "Average value is: %f ", avg );

return 0;

}

int getAverage( int *bal, int tot )

{

int i,s=0;

for(i=0;i<tot;i++)

{

}

s+=bal[i];

}

return s/tot;

Function declaration

Function call

Function Definition

Void fun(int ,int );

fun(a,b)

Void fun(int x,int y){}

Void fun(int ,float );

fun(a,f)

Void fun(int x,float y){}

Void fun(int *,float );

fun(&a,f)

Void fun(int *xp,float y){}

Void fun(int *,float *);

fun(&a,f)

Void fun(int *xp,float *yp){}

Programming in C [BCA I Sem 2014]

Unit IV

(12)

»» Recursion

Recursion is a programming technique that allows the programmer to express operations in terms of themselves. In C, this takes the form of a function that calls itself. A useful way to think of recursive functions is to imagine them as a process being performed where one of the instructions is to "repeat the process"(chaining of function/ Nesting of function).

This makes it sound very similar to a loop because it repeats the same code, and in some ways it is similar to looping. On the other hand, recursion makes it easier to express ideas in which the result of the recursive call is necessary to complete the task. Of course, it must be possible for the "process" to sometimes be completed without the recursive call.

Recursion is a special case of this process, where a function calls itself.

Example 1

main()

{

printf(“We are in Main!”); main();

}

[main() called]

We are in Main! [main() called] We are in Main!

[main() called]

We are in Main!

Example 2 Factorial of number

int factorial (int n)

{

if ( n < 0) return -1; /*Error*/

if (n == 0) return 1; /*Terminating condition*/

Programming in C [BCA I Sem 2014]

Unit IV

(13)

}

return (n * factorial (n -1));

factorial(5) 5*24  120 5 * factorial(5-1) 5 * factorial(4) 4*6  24 4 *
factorial(5)
5*24  120
5
* factorial(5-1)
5
* factorial(4)
4*6  24
4
* factorial(4-1)
4
* factorial(3)
3*2  6
3 * factorial(3-1)
3 * factorial(2)
2*1  2
2 * factorial(2-1)
2 * factorial(1)
1*1  1
1 * factorial(1-1) 1 * factorial(0) 1 1 factorial(0)is 1
1 * factorial(1-1)
1 * factorial(0)
1 1
factorial(0)is 1
* factorial(1-1) 1 * factorial(0) 1 1 factorial(0)is 1 Example 3 Multiplication of two numbers

Example 3 Multiplication of two numbers

#include<stdio.h>

int multiply(int,int);

int main()

{

int a,b,product; printf("Enter any two integers: "); scanf("%d%d",&a,&b);

product = multiply(a,b);

printf("Multiplication of two integers is %d",product);

return 0;

}

int multiply(int a,int b)

{

 

static int product=0,i=0;

if(i < a)

{

product = product + b;

i++;

multiply(a,b);

}

return product;

}

Advantages and Disadvantages of Recursion

Programming in C [BCA I Sem 2014]

Unit IV

(14)

Recursion is more elegant and requires few variables which make program clean. Recursion can be used to replace complex nesting code by dividing the problem into same problem of its sub-type. In other hand, it is hard to think the logic of a recursive function. It is also difficult to debug the code containing recursion.

»» Type Casting

Programming in C [BCA I Sem 2014]

Unit IV

(15)

Type casting is a way to convert a variable from one data type to another data type. For example, if you want to store a long value into a simple integer then you can type cast long to int. You can convert values from one type to another explicitly using the cast operator as follows:

(type_name) expression Consider the following example where the cast operator causes the division of one integer variable by another to be performed as a floating-point operation:

#include <stdio.h>

main()

{

int sum = 17, count = 5; double mean;

mean = (double) sum / count; printf("Value of mean : %f\n", mean );

}

When the above code is compiled and executed, it produces the following

result:

Value of mean: 3.400000

It should be noted here that the cast operator has precedence over division, so the value of sum is first converted to type double and finally it gets divided by count yielding a double value. Type conversions can be implicit which is performed by the compiler automatically, or it can be specified explicitly through the use of the cast operator. It is considered good programming practice to use the cast operator whenever type conversions are necessary.

Integer Promotion

Integer promotion is the process by which values of integer type "smaller" than int or unsigned int are converted either to int or unsigned int. Consider an example of adding a character in an int:

#include <stdio.h>

main()

 

{

 

int

i = 17;

char c = 'c'; /* ascii value is 99 */ int sum;

sum = i + c; printf("Value of sum : %d\n", sum );

}

Programming in C [BCA I Sem 2014]

Unit IV

(16)

When the above code is compiled and executed, it produces the following result:

Value of sum : 116

Here, value of sum is coming as 116 because compiler is doing integer promotion and converting the value of 'c' to ascii before performing actual addition operation.

Usual Arithmetic Conversion

The usual arithmetic conversions are implicitly performed to cast their values in a common type. Compiler first performs integer promotion, if operands still have different types then they are converted to the type that appears highest in the following hierarchy:

Programming in C [BCA I Sem 2014]

Unit IV

(17)

Programming in C [BCA I Sem 2014] Unit IV (17) The usual arithmetic conversions are not

The usual arithmetic conversions are not performed for the assignment operators, nor for the logical operators && and ||. Let us take following example to understand the concept:

#include <stdio.h>

main()

 

{

 

int

i = 17;

char c = 'c'; /* ascii value is 99 */

float sum;

sum = i + c; printf("Value of sum : %f\n", sum );

}

When the above code is compiled and executed, it produces the following

result:

Value of sum : 116.000000

Here, it is simple to understand that first c gets converted to integer but because final value is double, so usual arithmetic conversion applies and compiler convert i and c into float and add them yielding a float result.

»» Storage Class

Programming in C [BCA I Sem 2014]

Unit IV

(18)

Every variable and function in C programming has two properties: type and storage class. Type refers to the data type of variable whether it is character or integer or floating-point value etc. There are 4 types of storage class:

1 Automatic

2 External

3 Static

4 Register

A storage class defines the scope (visibility) and life time of variables and/or functions within a C Program.

Scope of Variable (ACTIVE): What region of the program a variable is actually available for use? [Range of availability]

Longevity (ALIVE): refers to the period during which a variable retains a given value during execution of program.

Variables are also categorized, depending on the place of their declaration,

Internal (local); declared within the particular function, External (global); declared outside of any function,

1. Automatic Variables (Private/ Local/ Internal)

auto is the default storage class for all local variables. They are created when the function is called and destroyed automatically when function is exited.

int Count; auto int Month;

The example above defines two variables with the same storage class. auto can only be used within functions, i.e. local variables. The keyword

used for Automatic storage class is 'auto'. used.

#include<stdio.h>

#include<conio.h> void main()

{

auto int a; printf(“%d”,a)

}

Output:

1285

As seen above, the output is garbage value.

2. External Variables (Public/ Global/ External)

Programming in C [BCA I Sem 2014]

Unit IV

(19)

Keyword 'auto' are rarely

auto int a; or int a;
auto int a;
or
int a;

Some applications it may be useful to have data which is accessible from within any block and/or which remains in existence for the entire execution of the program. Such variables are called global variables. The keyword used for External storage class is 'extern'.

Default value of that variable is zero. Scope of that variable is global. Variable is alive as long as the program’s execution doesn’t come to an end. External variable can be declared outside all the functions or inside function using 'extern' keyword.

Example 1

int a=10; Local variable will have void main() precedence over the global one. { printf(“%d”,a);
int a=10;
Local
variable
will
have
void main()
precedence over the global one.
{
printf(“%d”,a);

}

int fun()

{

}

Output:

Example 2

void main()

{

Programming in C [BCA I Sem 2014]

Unit IV

(20)

printf(“%d”,a); } int a=10; int fun() ‘a’ is a declared globally; but cannot be accessed
printf(“%d”,a);
}
int a=10;
int fun()
‘a’ is a declared globally; but
cannot be accessed by main.
{
Because it
is
declared after
main()
}

Now it is possible

void main()

{

extern int a; printf(“%d”,a);

}

int a=10;

int fun()

{

}

Output:

10

‘a’ is a declared after main() ;globally; then we have to declare that variable with
‘a’ is a declared after main()
;globally; then
we
have
to
declare
that
variable
with
extern
keyword
in
prior
function.

3. Static Variables It persists until the end of program, and can be declared by keyword

‘static’.

static int i;

It can be internal or external. If variable is static and internal than it is as good as auto in case of its scope. main()

{

int i; auto int i;

static int i;

}

Programming in C [BCA I Sem 2014]

Unit IV

(21)

Static variable is initialized only once, when program is compiled, and never again.

void fun()

{

static int x = 3;

}

4. Register Variables If we want to keep variable in register rather than to store in memory (RAM). By this faster execution.

register int x = 3;

Note: It is request by programmer, that means C will automatically convert register variable into non-register variable.

Storage

Default

Scope

Lifetime

auto

Memory

Garbage(unpredictable)

Local to the block in which it is declared

Till the control remain in the block in which it is declared

register

Register

Garbage(unpredictable)

Local to the block in which it is declared

Till the control remain in the block in which it is declared

     

Local to the block in which it is declared

Value

persist in

static

Memory

ZERO [0]

between

function call

       

Alive and

extern

Memory

ZERO [0]

Global

Active till

the program

Programming in C [BCA I Sem 2014] Unit IV (22) execution does not comes to
Programming in C [BCA I Sem 2014]
Unit IV
(22)
execution
does not
comes to
end