UNIT-IV

FUNCTIONS
4.1 Designing Structured Programs:

A function is a self contained program segment that carries out a specific, well-defined task.

Every c program can be thought of as a collection of these functions. A large problem

has to be split into smaller segments so that it can be efficiently solved. This is where,
functions come into the picture. They are actually the smaller segments, which help solve the
large problems.
The C language supports two types of functions:

1. Library Functions
2. User defined Functions
 The library functions are pre-defined set of functions. Their task is limited. A user
cannot understand the internal working of these functions. The user can only use the
functions but can‟t change or modify them.
Ex: sqrt(81) gives result 9. Here the user need not worry about its source code, but the result
should be provided by the function.

 The User defined functions are totally different. The functions defined by the user
according to his requirement are called as User defined functions. The user can
modify the function according to the requirement. The user certainly understands the
internal working of the function. The user has full scope to implement his own ideas
in the function. Thus the set of such user defined functions can be useful to another
programmer. One should include the file in which the user-defined functions are
stored to call the functions in the program.
Ex: Let square(9) is user-defined function which gives the result 81.

Here the user knows the internal working of the square() function, as its source code is
visible. This is the major difference between the two types of functions.
Why we use functions?

 If we want to perform a task repetitively then it is not necessary to re-write the

particular block of the program again and again. Shift the particular block of
statements in a user-defined function. The function defined can be used for any
number of times to perform the task.
 Suppose a section of code in a program calculates the simple interest for some
specified amount, time and rate of interest. Consider a scenario, wherein later on in
the same program the same calculation has to be done for a different amount, rate and
time.
 Functions come to rescue here. Rather than writing the same instructions all over
again, a function can be written to calculate the simple interest for any specified
amount, time and rate. The program control is then transferred to the function, the
calculations are performed and the control is transferred back to the place from where
it was transferred.
  Using functions large programs can be reduced to smaller ones.
 It is easy to debug and find out the errors in it. It also increases readability.
 Programs containing functions are also easier to maintain, because modifications, if
required, can be confined to certain functions within the program. In addition to this
program, functions can be put in a library of related functions and used by many
programs, thus saving on coding time.
 Facilitates top-down modular programming. In this programming style, the high level
of the overall program is solved first while the details of each lower level functions
are addressed later.

4.2 User-defined functions-Declaring a function

We know that functions are classified as one of the derived data types in C. So, we can define
functions and use them like any other variable in C programs. Therefore we can observe the
following similarities between the functions and variables in C.

1. Both function names and variable names are considered as identifiers.

2. Like variables, functions also have types (data types) associated with them.

3. Like variables, function names and their types must be declared and defined before they are
used in a program.
In order to make use of a user-defined function, we need to establish three elements that are
related to functions.
1. Function declaration
2. Function call
3. Function defining

4.3Signature of function

1. A function declaration in C tells the compiler about function name, function

parameters and return value of a function. The actual body of the function can be
defined separately.Like variable in C, we have to declare functions before their first
use in program.

Syntax of Function Declaration:

return type function name(type arg1, type arg2 .....);

For Example
 Declaration of a function with no input parameters
void printMatrix();
 Declaration of a function with one input parameter and integer return type
int isEvenNumber(int num);
 Declaration of a function with multiple input parameter and integer return type.
int getSum(int num1, int num2);
 Declaration of a function with no input parameters and integer return type.
int getRandomNumber();
 Important Points about Function Declaration:

 Function declaration in C always ends with a semicolon.

 By default the return type of a function is integer(int) data type.
 Function declaration is also known as function prototype.
 Name of parameters are not compulsory in function declaration only their type is
required. Hence following declaration is also valid.
int getSum(int, int);
If function definition is written before main function then function declaration is not required
whereas, If function definition is written after main function then we must write function
declaration before main function.

2. Function call: A compiler executes the function when a semi-colon is followed by

function name. A function can be called simply by using its name like other C statement,
terminated by semicolon. A function can be called any number of times. A function can
be called from other function, but a function cannot be defined in another function. We
can call main ( ) function from other functions. But always a function must and should at
least call by main once.

3. Function definition (Function Implementation):It is an independent program module

that is specifically written to implement the requirements of the function. It includes the
following elements:

 Function type
 function name,
 list of parameters (arguments)
 local variable declarations
 body of the functions (list of statements)
 a return statement.

All the six elements are grouped into two parts, namely,

1. Function header (First three elements)

2. Function body (Last three statements )

The function structure: The general syntax of a function in C is:

type_specifier function_name (arguments)

{
local variable declaration;
 statement-1;
statement-2;
....................
return (value);
}

 The type_specifier specifies the data type of the value, which the function will return.
If no data type is specified, the function is assumed to return an integer result. The
arguments are separated by commas. A function is not returning anything; then we
need to specify the return type as void. A pair of empty parentheses must follow the
function name if the function definition does not include any arguments.
 The parameters list / arguments list declares the variables that will receive the data
sent by the calling program. They serve as input data to the function o carry out the
specific task.

4.4Parameters and return type of a function:

4.4.1 Parameters:

1. Actual parameters: The arguments of calling functions are called as actual

parameters.
2. Formal parameters: The arguments of called functions are called as formal
parameters.
Note:A semicolon is not used at the end of the function header.

The body of the function may consist of one or many statements necessary for performing
the required task. The body consists of three parts:
1. Local variable declaration
2. Function statements that perform the task of the function
3. A return statement that returns the value evaluated by the function. If a function is not
returning any value then we can omit the return statement.
EX: 1. /* program to call main function from another user defined function*/
void main()
{
message();
}
void message ( )
{
printf(“\n welcome to C lab”);
main();

EX: 2/* Program to show how user defined function is called */

#include<stdio.h>
int add(int,int);//declaration
void main()
{
int x=1,y=2,z;
z=add (x,y);//calling
printf(“z=%d”,z);
}
add (int a,int b) //defining
{
return (a+b);
}
4.4.2 Return values and their types:

The value evaluated by any function is send back to the calling function by using return
statement. The called function can only return only one value per call. The return statement has
the following forms:
 return;
 return(expression);

 The first form does not return any value to the calling function; it acts as the closing
brace of the function. When a return is encountered, the control is immediately passed
back to the calling function.

 A function may have more than one return statement. This situation arises when the value
returned is based on certain conditions:

EX:
if(a>b)
return(1);
else
return(0);

Note:

 All functions by default return integer type data. But, we can force a function to return a
particular type of data by using a type specifier in the function header as discussed
earlier.

 Absence of return statement in called function indicates that no value is returned to the
calling function, such functions are called as void.

How function works?

 Once a function is defined and called, it takes some data from the calling function and
returns a value to the called function.

 Whenever a function is called, control passes to the called function and working of the
calling function is stopped. When the execution of the called function is completed,
control returns back to the calling function and execute the next statement.

 The values of actual arguments passed by the calling function are received by the formal
arguments of the called function. The number of actual and formal arguments should be
the same.
  Extra arguments are discarded if they are defined. If the formal arguments are more than
the actual arguments then the extra arguments appear as garbage. Any mismatch in data
type will produce the unexpected result.

 The function operates on formal arguments and sends back the result to the calling
function. The return ( ) statement performs this task.
4.5 Passing parameters to function:

Depending upon the arguments present, return value send the result back to the calling function.
Based on this, the functions are divided into 4 types:

1. Without arguments and return values.

2. Without arguments and but with return values.
3. With arguments but without return values.
4. With arguments and return values.

Without arguments and return values

Calling function Analysis Called function
main()
{ add ( )
................ {
................ ............

add ( ); No arguments are passed. ............
................ ............
................ No values are sent back  ............
} }

In this type neither the data is passed through the calling function nor is the data sent back from
the called function.

There is no data transfer between calling function and called function.

If the functions are used to perform any operations, they act independently. They read data
values and print result in the same block.

This type of functions may be useful to print some messages, draw a line or split the line etc.

Ex: /* program to display message using user-defined function*/ void main ( )

{
void message ( ); /*FUNCTION PROTOTYPE*/
message ( ); /*FUNCTION CALL*/
}
void message ( ) /*FUNCTION DEFINITION*/
{
printf(“Have a nice day”); }

Explanation: This program contains a user-defined function named message ( ). It requires no

arguments and returns nothing. It displays only a message when called.

Without arguments and but with return values:

/* program to receive values from the user defined function without passing any value
through main ( )*/
void main( )
{
int z;
z=add ( ); /* FUNCTION CALL*/
print(“sum = %d”,z);
}
add ( ) /* FUNCTION DEFINITION*/
{

int a=2, b=3, y;

y=a+b;
return (y);
}
Calling function Analysis Called function
main() add ( )
{ {
int z; int a=2,b=3,y;


z=add(); No arguments are passed. y=a+b;
printf(“sum = %d”,z); No values are sent back  return(y);
} }

In this type of function no arguments are passed through the main ( ) function (calling function).
But the called function (add ( )) returns the values. Here the called function is independent. It re
data from the keyboard or generates form the initialization and returns the values. In this type
both the calling function and called function are partly communicated with each other.

With arguments but without return values

In this type of functions arguments are passed to the calling function. The called function
operates on the values. But no result is sent back. This called function is also partly dependent on
the calling function. The result obtained is utilized in the called function only.

Ex: /* program to calculate sum of two numbers using user-defined function*/

void main ( )

{
void add (int, int); /* FUNCTION PROTOTYPE */
int a, b; add (int x,int y) /* FUN DEFINITION*/
clrscr( ); {
printf(“enter the values of a and b”); int z; /*Local variable declaration*/
scanf(“%d%d”, &a,&b); z = x+y;
add(a,b); /* FUNCTION CALL */ printf(“sum = %d”,z);
getch( ); }
}

Explanation: in this program two values are passed to add ( ) function. The add ( ) function
receives argument from main ( ) and displays sum of a and b. But it returns nothing.

Calling function Analysis Called function

void main()

{ Arguments are passed. add (int x, int y )
int a,b; No values are sent back  {
printf(“enter the value of a &
b”); int z; //Local variable
scanf(“%d %d”, &a, &b); z = x + y;
add (a,b ); printf(“ sum = %d”,z);
} }

With arguments and return values:

In this type of functions a copy of actual argument is passed to the formal argument from the
calling function to the called function. Called function operates on those data values and it will
return the result to the calling function. Here data is transferred between calling and called
functions.

Ex: /* program to calculate sum of two numbers using user-defined function */

void main()
{
void add(int, int); /*Function prototype declaration */
int a, b, z;
clrscr( );
printf(“enter the values of a and b”);
scanf(“%d %d”, &a, &b);
z=add (a,b); /* Function CALL*/
printf(“sum = %d”, z);
getch();
}
add (int x, int y) /* Function Definition */
{
return (x+y);
}
Calling function Analysis Called function
 void main()
{
int a, b, z;
printf(“enter the value of a &
b”); add (int x, int y )
scanf(“%d %d”, &a, &b); {

z = add (a,b ); Arguments are passed.
printf(“ sum = %d”, z); values are send back  return ( x + y);
getch( );
} }

Data transfer between the functions / Parameters Passing:

The technique of passing data from one function to another is known as parameters passing.
Parameter passing can be done in two ways:

Call by value
Call by reference

4.6 Call by value:

In this type value of actual arguments are passed to the formal arguments and the operation is
done on the formal arguments. Any change made in the formal arguments does not affect the
actual arguments because formal arguments are photocopy of actual arguments.

Changes made in the formal arguments are local to the block of the called function. Once the
control returns back to the calling function the changes made vanish.

/* Example program to send values by call by value*/

void main( )
{
int a=2,b=3;
void display(int, int);
clrscr( );
display(a, b);
printf(“\n\n In main \t a=%d \t b=%d”, a, b);
getch( );
}

void display (int x, int y)

{
printf(“\n In display( ) before change \t a=%d \t b=%d\n”, x,y);
x=10;
y=12;
printf(“\n In display( ) after change \t a=%d \t b=%d \n”, x, y);
}
/* Example program on swapping of 2 numbers by using call by value */ void swap(int,int);

void main( )
{
int a,b;
printf(“enter any two values\n”);
scanf(“%d%d”,&a,&b);
swap(a,b);
}
void swap(int x,int y)
{
int t;
t=x;
x=y;
y=t;
printf(“after interchange\n”);
printf(“%d %d”,x,y);
}

4.7 Call by reference:

In this type instead of passing values, addresses (reference) are passed. Function operates on
addresses rather than values. Here the formal arguments are pointers to the actual arguments.
Formal arguments point to the actual arguments. Hence the changes made in the arguments are
permanent. i.e., the changes made in formal arguments will affect the actual arguments.

/* Example program to send values by call by reference*/

void main( )
{
int a=2,b=3;
void display(int*, int*);
clrscr();
display(&a, &b);
printf(“\n\n in main \t a=%d \t b=%d”, a, b);
getch();
}
void display (int *x, int *y)
{
printf(“\n in display( ) before change \t a=%d \t b=%d\n”, *x, *y);
*x=10;
*y=12;
printf(“\n in display( ) after change \t a=%d \t b=%d \n”, *x, *y);
}

/* Ex 2: Swapping of 2 numbers */
#include<stdio.h>

#include<conio.h>
void swap(int *,int *);
void main( )
{
int a,b;
printf(“enter any two values\n”);
scanf(“%d%d”,&a,&b);
swap(&a,&b);
printf(“after interchange\n”);
printf(“%d %d”,a,b);
getch( );
}
void swap(int *x,int *y)
{
int t;
t=*x;
*x=*y;
*y=t;
}
Function returning more values:

We know that a function can return only one value per call. But we can force the function to
return more than one value per call by using call by reference.
void main( )
{
int x,y, add, sub, change (int*,int*,int*,int*);
clrscr();
printf(“\n enter values of x&y”);
scanf(“%d %d”, &x, &y);
change(&x, &y, &add, &sub);
printf(“\n Addition=%d \n Subtraction=%d”, add, sub);
getch();
}
change(int *a, int *b, int *c, int *d)
{
*c=*a+*b;
*d=*a-*b;
}

Explanation: In this program return statement is not used. Still function returns more than one
value. Actually, no values are returned. Once the addresses of the variables are available, we can
directly access them and modify their contents.

Note:
The memory address of any variable is unique.

If we declare the same variable for actual and formal arguments, their memory addresses will be
different from each other.

4.8 Standard functions and libraries

In „c‟, a number of pre-defined functions are available to perform various tasks. To use these
functions, we have to include the corresponding header file in which the function is available.

stdio.h:- (standard input output library functions)

When any of the functions getchar ( ), qets ( ), putchar ( ), puts ( ), scanf( ), printf ( ) is used the
header file stdio.h has to be included.

math.h:- (mathematical functions)

pow ( ):-This function returns xn value. Syntax:- pow (x,n);

Eg:- pow (5,3)=53=125.

sqrt ( ):-This function performs square root of the given number. Syntax:- sqrt (n);

Eg:- sqrt (81)=9.

log ( ):-This function returns natural logarithm of the given number. Syntax:- log (n);

Eg:- log (8);

log10 ( ):-This functions returns logarithm value of the given number to the base 10.

Syntax:- log10 (n);

Eg:- log10(10)=1

exp( ):-This function returns er value.

Syntax:- exp (x);
Eg:- exp(3);

ceil ( ):-This function returns the next higher integer value of the given number. Syntax:- ceil(n);
Eg:- ceil (17.7)=18 ceil (16.1)=17.

floor( ):-This function returns the integer value less than or equal to the given number.

Syntax:- floor (n);

Eg:- floor (17.7) = 17 floor(16.1) = 16.

Cos, acos, cosh, sin, asin, sinh, tan, atan, tanh are also the functions under this header file.

Stdlib.h:- (standard Library functions header file)

abs( ):-This functions returns the absolute value of a given, integer. Syntax:- abs (integer value);

Eg:- abs (-17); =17.

fabs( ):-This functions returns absolute value (modulus) of a given floating point number.

Syntax:- fabs (float value);

Eg:- fabs (-17.6) = 17.6.

atoi ( ):-This function converts the given string to an integer value. Syntax:- atoi(string);

Eg:- atoi (“123”) =123.

atof ( ):-This function converts the given string into floating point value. Syntax:- atof (string);

Eg:- atof (“ 123.56”) = 123.560000.

ctype. h:- (character testing and conversion functions)

(i) isalpha( ):-This function checks whether the given character is an alphabet (or)
not. If it is an alphabet, it returns a non-zero value and otherwise a zero value.

Syntax:- is alpha(„a‟); True
Eg:- isalpha (“a‟) True (non-zero)
isalpha(“2‟) Flase (zero)

isalnum( ):- This function checks whether the given character is an alphabet or a number. If true
it returns a non-zero value otherwise a zero value.
Eg:- isalnum(“1‟) True (non-zero)
isalnum(“q‟) False (zero)

isdigit ( ):-This function checks whether the given character is a digit or not. If true it returns a
non-zero value otherwise a zero value.
Eg:- isdigit (“a‟) True (non zero)
isdigit(“*‟) False (zero)

islower ( ):-This function checks whether the given character is a Lower case alphabet or not. If
it is a small letter it returns a non-zero value otherwise a zero value.
Eg:- islower (“b‟) True (non-zero)
islower(“A‟) False (zero)
isupper ( ):-This function checks whether the given character is a upper case alphabet or not. If it
is a capital letter is returns a non-zero value otherwise a zero value.
Eg: isupper (“B‟) True (non-zero)
Isupper(”q‟) False (zero)
toupper ( ):-This function converts the given small letters to an upper case letter.

Eg:- toupper (“b‟)=B

toupper(“q‟)=Q

tolower ( ):- This function converts the given capital letters to a Lower case letter.

Eg;- tolower (“B‟) =b

tolower (“Q‟)=q

toascii( ):-This function returns the equivalent ASCII value for the given character.

Eg:- toascii (“a‟) = 97

toascii(“B‟) = 66

COMMONLY USED LIBRARY FUNCTIONS:

clrscr( ):

This function clears the previous output from the screen and displays the output of the current
program from the first line of the screen. This function is defined in conio.h header file.

Syntax: clrscr();

exit( ):

This function terminates the program. It is defined in the process.h header file.

Syntax: exit( );

4.9 Recursion

Recursion is a special case of process, where a function calls itself. A function is called recursive
if a statement within the body of a function calls the same function.

factorial(x)
int x;
{
if (x = =1)
return(1);
else
return(x * factorial(x-1));
}
When writing recursive functions, you must have an If stmt somewhere in the recursive function
to force the function to return without recursive call being executed. If you do not do this and
you call the function, you will fall in an indefinite loop, and will never return from the called
function.
/*program to find factorial of a given number using a Recursive function*/ #include<stdio.h>
int factorial(x)
int x;
{
if (x<=1)
return(1);
else
return(x*factorial(x-1));
}
main()
{
int n,fn;
clrscr();
printf("enter n");
scanf("%d",&n);
fn=factorial(n); /* Function Call */
printf("the factorial %d is %d\n",n,fn);
getch(); }

In case the value of n is 4, main() would call factorial() with 4 as its actual argument, and
factorial() will send back the computed value. But before sending the computed value, factorial()
calls factorial() and waits for a value to be returned.

factorial(4) returns 4*factorial(3) 4*6 = 24

factorial(3) returns 3*factorial(2) 3*2 =6
factorial(2) returns 2*factorial(1) 2*1 =2
factorial(1) returns1 Back substitution

/* A Program to find factorial of a given number using recursion. */

#include<stdio.h>
#include<conio.h>
int factorial(int);
void main( )
{
int n,k;
printf(“enter any number\n”);
scanf(“%d”,&n);
k=factorial(n);
printf(“factorial of %d is %d”,n,k);
getch( );
}
int factorial(int x)
{
int fact;
if(x==0||x==1)
return(1);
else
{
fact=(x*factorial(x-1));
return(fact);
}
}
/* A Program to print Fibonacci series using recursion. */
#include<stdio.h>
#include<conio.h>
int fib(int);
void main()
{
int i,n;
printf(“enter limit\n”);
scanf(“%d”,&n);
for(i=1;i<=n;i++)
printf(“%d “,fib(i));
getch( );
}

int fib(int x)
{
if(x==1)
return 0;
else if(x==2)
return 1;
else
return(fib(x-1)+fib(x-2));
}
4.9.1 Limitations of Recursion:

Advantages
1. Reduce unnecessary calling of function.
2. Through Recursion one can Solve problems in easy way while its iterative solution is
very big and complex.
Disdvantages
1. Recursive solution is always logical and it is very difficult to trace.(debug and
understand).
2. In recursive we must have an if statement somewhere to force the function to return
without the recursive call being executed, otherwise the function will never return.
3. Recursion takes a lot of stack space, usually not considerable when the program is small
and running on a PC.
4. Recursion uses more processor time.

Dynamic memory allocation: Dynamic memory allocation uses predefined functions to

allocate and release memory for data while the program is running. It effectively postpones the
data definition ,but not the declaration to run time.
To use dynamic memory allocation ,we use either standard data types or derived
types .To access data in dynamic memory we need pointers.

4.10 MEMORY ALLOCATION FUNCTIONS:

Four memory management functions are used with dynamic memory. Three of
them,malloc,calloc,and realloc,are used for memory allocation. The fourth ,free is used to return
memory when it is no longer needed. All the memory management functions are found in
standard library file(stdlib.h).

1. BLOCK MEMORY ALLOCATION(MALLOC) :

The malloc function allocates a block of memory that contains the number of bytes
specified in its parameter. It returns a void pointer to the first byte of the allocated memory. The
allocated memory is not initialized.

Declaration:
void *malloc (size);

The type size_t is defined in several header files including Stdio.h. The type is usually an
unsigned integer and by the standard it is guaranteed to be large enough to hold the maximum
address of the computer. To provide portability the size specification in malloc’s actual
parameter is generally computed using the sizeof operator. For example if we want to allocate an
integer in the heap we will write like this:

Pint=malloc(sizeof(int));
 Malloc returns the address of the first byte in the memory space allocated. If it is not
successful malloc returns null pointer. An attempt to allocate memory from heap when memory
is insufficient is known as overflow.

The malloc function has one or more potential error if we call malloc with a zero size, the
results are unpredictable. It may return a null pointer or it may return someother implementation
dependant value.

Ex:
If(!(Pint=malloc(sizeof(int)))) // no
memory available
exit(100);
//memory available
…

In this example we are allocating one integer object. If the memory is allocated successfully,ptr
contains a value. If does not there is no memory and we exit the program with error code 100.

2. CONTIGIOUS MEMORY ALLOCATION(calloc) :

Calloc is primarily used to allocate memory for arrys.It differs from malloc only in Void
that it sets memory to null characters. The calloc function declaration:
*calloc(size_t element_count, size_t element_size);

The result is the same for both malloc and calloc.

calloc returns the address of the first byte in the memory space allocated. If it is not
successful calloc returns null pointer.
Example:
if(!(ptr=(int*)calloc(200,sizeof(int))))
//no memory available
exit(100);
//memory available
…
In this example we allocate memory for an array of 200 integers.

3. REALLOCATION OF MEMORY(realloc):

The realloc function can be highly inefficient and therefore should be used
advisedly. When given a pointer to a previously allocated block of memory realloc
changes the size of the block by deleting or extending the memory at the end of the
block. If the memory can not be extended because of other allocations realloc allocates
completely new block,copies the existing memory allocation to the new location,and
deletes the old allocation.

Void *realloc(void*ptr,size_t newsize);

Ptr
 Before

18 55 33 121 64 1 90 31 5 77

10 Integers

Ptr=realloc(ptr,15*sizeof(int)); New elements

not initialized

ptr
18 55 33 121 64 1 90 31 5 77 ? ? ? ? ?

15 Integers

After
Releasing Memory(free):When memory locations allocated by malloc,calloc or realloc are no
longer needed, they should be freed using the predefined function free. It is an error to free
memory with a null pointer, a pointer to other than the first element of an allocated block, a
pointer that is a different type then the pointer that allocated the memory, it is also a potential
error to refer to memory after it has been released.

Void free(void *ptr);

Ptr ptr

Before After
free(ptr);

In above example it releases a single element to allocated with a malloc,back to heap.

BEFORE AFTER

… …

Ptr 200 integers ptr 200 integers

free(ptr);
In the above example the 200 elements were allocated with calloc. When we free the
pointer in this case, all 200 elements are return to heap. First, it is not the pointers that are being
released but rather what they point to. Second , To release an array of memory that was allocated
by calloc , we need only release the pointer once. It is an error to attempt to release each element
individually.
Releasing memory does not change the value in a pointer. Still contains the address in the
heap. It is a logic error to use the pointer after memory has been released.

4.11 Array of pointers:

Array are closely related to pointers in C programming but the important difference between
them is that, a pointer variable takes different addresses as value whereas, in case of array it is
fixed.
This can be demonstrated by an example:
#include <stdio.h>
int main()
{
char charArr[4];
int i;

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

{
printf("Address of charArr[%d] = %u\n", i, &charArr[i]);
}

return 0;
}
When you run the program, the output will be:
Address of charArr[0] = 28ff44
Address of charArr[1] = 28ff45
Address of charArr[2] = 28ff46
Address of charArr[3] = 28ff47

Note: You may get different address of an array.

Notice, that there is an equal difference (difference of 1 byte) between any two consecutive
elements of array charArr.
But, since pointers just point at the location of another variable, it can store any address.
Relation between Arrays and Pointers
Consider an array:
int arr[4];
  In C programming, name of the array always points to address of the first element of an
array.
 In the above example, arr and &arr[0] points to the address of the first element.
&arr[0] is equivalent to arr
 Since, the addresses of both are the same, the values of arr and &arr[0] are also the same.
 arr[0] is equivalent to *arr (value of an address of the pointer)
 Similarly, &arr[1] is equivalent to (arr + 1) AND, arr[1] is equivalent to *(arr + 1).
 &arr[2] is equivalent to (arr + 2) AND, arr[2] is equivalent to *(arr + 2).
 &arr[3] is equivalent to (arr + 3) AND, arr[3] is equivalent to *(arr + 3)..
 &arr[i] is equivalent to (arr + i) AND, arr[i] is equivalent to *(arr + i).
In C, you can declare an array and can use pointer to alter the data of an array.
Example: Program to find the sum of six numbers with arrays and pointers
#include <stdio.h>
int main()
{
int i, classes[6],sum = 0;
printf("Enter 6 numbers:\n");
for(i = 0; i < 6; ++i)
{
// (classes + i) is equivalent to &classes[i]
scanf("%d",(classes + i));

// *(classes + i) is equivalent to classes[i]

sum += *(classes + i);
}
printf("Sum = %d", sum);
return 0;
}
 TUTORIAL QUESTIONS

1. WACP to Check given number is Prime and Armstrong Number or not using function.
2. Implement a c program to print 1 to 100 numbers without using loops.

3. Implement a C program to multiply three numbers by passing it as arguments to a

function.

4. Implement a c program to reverse string using function

5. Implement a c program to find GCD using recursion

ASSIGNMENT QUESTIONS

SET 1:
1. Differentiate call by value and call by reference.
2. Implement a C program to print factorial of given number using with arguments
and with return type.
SET 2:
1. Discuss recursive function with an example.
2. Implement a C program to find power and square root of any number using standard
functions.
SET 3:
1. Implement a c program to transpose the given matrix.
2. Implement a C program to factorial using recursive functions.
SET 4:
1. Discuss about storage classes.
2. Implement a C program to allocate memory for 10 integers dynamically.
SET 5:
1. Discuss about inter function communications.
2. List out the difference between malloc() and calloc()?
SET 6:
1. Explain the difference between static allocation and dynamic allocation?
2. Implement Fibonacci series using recursion.

Important questions

1. Write a program to demonstrate passing an array argument to a function? Consider the

problem of finding largest of N numbers defined in an array.
 (b) Write a recursive function power(base, exponent) that when invoked returns base
exponent?
2. What do you mean by functions? Give the structure of the functions and explain about
the arguments and their return values?
3. (a) Distinguish between the following.

(i) Actual and Formal arguments?

(ii) Global and Local variables?

(iii) Automatic and Static variables?

(c) Explain in detail about pass by value and pass by reference. Explain with a sample program?

4. (a) Distinguish between formal variable and actual variable.

(b) Distinguish between Local and Global variable.

(c) Distinguish between Call by value and Call by reference.

5. (a) What are the advantages and disadvantages of recursion?

(b) Write a C program to find the factors of a given integer using a function.

6. (a) Give some important points while using return statement.

(b) Write short notes on scope of a variable.

7. (a) Write short notes on auto and static storage classes.

(b) Write short notes on call by reference.

8. (a) Distinguish between user defined and built-in functions.

(i) What is meant by function prototype? Give an example for function prototype.

9. (a) Distinguish between getchar and scanf functions for reading strings.
(i) Write a program to count the number of words, lines and characters in a text.

10. (a) What do you mean by functions? Give the structure of the functions and explain about
the arguments and their return values.
(i) Write a C program that uses a function to sort an array of integers.