UNIT-III FUNCTIONS AND STORAGE CLASSES

Function: Definition of function - Declaration of function - Pass by Value - Pass by Reference -

Recursion Pointers: Definition – Initialization - Pointer Arithmetic – Pointers and Array.
3.1. Defining a function
A function is a self-contained block of program statements that performs a particular task. It is
often defined as a section of a program performing a specific job. A subset of a concept called
subroutine.
3.1.1. Need for Functions
⚫ It breaks up a program into easily manageable chunks and makes programs easier to
understand.
⚫ Improves the reusability of code.
⚫ Easy debugging of code.
⚫ Used to protect data
⚫ Different programmers working on one large project can divide the workload by writing
different functions.
3.2. Declaration and Definition of a Function
All C programs contain at least one function, called main() where execution starts. When a
function is called, the code contained in that function is executed, and when the function has
finished executing, control returns to the point at which that function was called. Functions are
used by calling them from other functions. When a function is used, it is referred to as the
‘called function’. Such functions often use data that is passed to them from the calling function.
Parameters provide the means by which you pass information from the calling function into
the called function.

3.2.1. Function Prototype Declaration

In a C program, a user-written function should normally be declared prior to its use to allow
the compiler to perform type checking on the arguments used in its call statement or calling
construct. The general form of this function declaration statement is as follows:
return_data_type function_name (data_type variable1,...);
Or
return_data_type function_name (data_type_list);
There are three basic parts in this declaration.
⚫ function_name This is the name given to the function and it follows the same naming
rules as that for any valid variable in C.
⚫ return_data_type This specifi es the type of data given back to the calling construct by
the function after it executes its specifi c task.
⚫ data_type_list This list specifi es the data type of each of the variables, the values of which
are expected to be transmitted by the calling construct to the function.
Rules:
⚫ The name of the function is global.
⚫ No function can be defined in another function body.
⚫ Number of arguments must agree with the number of parameters specified in the prototype.
⚫ The function return type cannot be an array or a function type.
⚫ when a function takes no parameters, the inclusion of the word “void” inside the
parentheses is optional
Example:
float FtoC(float);
float FtoC(float faren);
3.2.2. Function Definition
⚫ The collection of program statements in C that describes the specific task done by the
function is called function definition.
⚫ It consists of
* Function header
* Function body
The general form of the function definition is as follows
return_data_type function name(data_type variable1,data_type variable2,……)
{
/* Function Body */
}
The function header in this definition is
return_data_type function name(data_type variable1,data_type variable2,……)
and the portion of program code within the braces is the function body. The function declaration
does not require the semicolon at the end. The list of variables in the function header is referred
to as the formal parameters.
return Statement
The general form of the return statement is as follows:
return expression;
or
return(expression);
where expression must evaluate to a value of the type specified in the function header for the
return value. A function can only return one value. A function with return type void does not
return any values. There may be more than one return statement in a function, but only one
return statement will be executed per calling to the function.
3.2.3. Function Calling
A function will carry out its expected action whenever it is invoked (i.e. whenever the function
is called) from some portion of a program which means the program control passes to that of
the
called function. Once the function completes its task, the program control is returned back to
the calling function. A function with returned type void does not return any value. It only
returns the control from called function to calling function.
The general form of the function call statement is
function_name(variable1, variable2,…);
or
variable_name = function_name(variable1,variable2,…);
If there are no arguments to be passed in the function, i.e., the argument is void, then the calling
statement would be
function_name();
or
variable_name = function_name();
Information will be passed to the function via special identifiers or expression called arguments
or actual parameters and returned via the return statement.
Rules to write parameters:
❖ The number of parameters in the actual and formal parameter lists must be consistent.
❖ Parameter association in C is positional. This means that the first actual parameter
corresponds to the first formal parameter, the second matches the second and so on.
❖ Actual parameters and formal parameters must be of compatible data types.
❖ Actual (input) parameters may be a variable, constant, or any expression matching the type
of the corresponding formal parameter.
Example Program
Convert a temperature from Fahrenheit scale to Celsius scale
3.3. Passing Arguments to a Function
The technique used to pass data to a function is known as parameter passing. Data are
passed to a function using one of the two techniques: pass by value or call by value and pass
by reference or pass by reference.
3.3.1. Pass by Value
In pass by value or call by value, a copy of the data is made and the copy is sent to the
function. The copies of the value held by the arguments are passed by the function call. Since
only copies of values held in the arguments are passed by the function call to the formal
parameters of the called function, the value in the arguments remains unchanged. In other
words, as only copies of the values held in the arguments are sent to the formal parameters, the
function cannot directly modify the arguments passed.
Example Program
#include <stdio.h>
void swap(int, int);
int main()
{
int x, y;
printf("Enter the value of x and y\n");
scanf("%d%d",&x,&y);
 printf("Before Swapping \nx = %d\ty = %d\n", x, y);
swap(x, y);
printf("After Swapping\nx = %d\ty = %d\n", x, y);
return 0;
}
void swap(int a, int b)
{
int temp;
temp = b;
b = a;
a = temp;
printf(“Inside Swap function: Values of a and b is %d %d\n",a,b);
}
Output
Enter the value of x and y
50 30
Before Swapping
x = 50 y = 30
Inside Swap function: Values of a and b is 30 50
After Swapping
x = 50 y = 30
No swapping takes place. Now when the function swap is called, the system automatically
creates two new variables (called a and b in this case). These will contain a copy of the values
that are specified in the function call (i.e., the value of x and the value of y). All the operations
performed by the function operate on the copies of the values (a, b), and will not affect the
original values (x, y).

3.3.2. Pass by Reference

The second technique, pass by reference or call by reference, sends the address of the data
rather than a copy. In this case, the called function can change the original data in the calling
function. Whenever the data in the calling function have to be changed, one must pass the
variable’s address and use it to change the value. Here values are passed by handing over the
addresses of arguments to the called function, it is possible to change the values held within
these arguments by executing the function.
Example Program
#include <stdio.h>
void swap(int *, int *);
int main()
{
int x, y;
printf("Enter the value of x and y\n");
scanf("%d%d",&x,&y);
printf("Before Swapping \nx = %d\ty = %d\n", x, y);
swap(&x,&y);
printf("After Swapping\nx = %d\ty = %d\n", x, y);
return 0;
}
void swap(int *a, int *b)
{
int temp;
temp = *b;
*b = *a;
*a = temp;
printf(“Inside Swap function: Values of a and b is %d %d\n",*a,*b);
}
Output
Enter the value of x and y
50 30
Before Swapping
x = 50 y = 30
Inside Swap function: Values of a and b is 30 50
After Swapping
x = 30 y = 50
The values have been exchanged by the function swap(). Within the main() function, the
& operator causes the address of arguments x and y to be passed in the call to swap(). In the
swap() function header, the addresses being passed from the calling function are received in
pointer type variables (int *a, int *b). Within the swap() function body, the * operator is used
to retrieve values held at the addresses that were passed.
3.4. Types of Function
There are two types of functions namely
⚫ Library Functions: Function defined are included with C compilers are known as library
functions. These functions are built-in, pre-compiled and ready to use. Example:
printf(),sqrt()
⚫ User Defined Functions: Functions defined by an end programmer is known as user
defined function. A programmer can define any number of function depending on the need.
Function usage based on parameters and return type
Functions can be used in a program in various ways:
❖ Function that perform operations on their parameters and return a value.
❖ Function that manipulates information on their parameters and return a value that simply
indicates the success or failure of that manipulation.
❖ Function having no return type that is strictly procedural.
Based on the prototype, there can be 4 different types of user-defined functions, they are:
• Function with no arguments and no return value.
• Function with no arguments and a return value.
• Function with arguments and no return value.
• Function with arguments and a return value.

3.4.1. Function with no arguments and no return value

Function with no return no argument, neither returns a value nor accepts any argument.
This type of function does not communicate with the caller function. It works as an independent
working block.
Syntax:
void function_name()
 {
// Function body
}
Example:

#include <stdio.h>
void checkPrimeNumber();
int main(){
checkPrimeNumber(); // argument is not passed
return 0;
}
// return type is void meaning doesn't return any valuevoid checkPrimeNumber(){
int n, i, flag = 0;

printf("Enter a positive integer: ");

scanf("%d",&n);

for(i=2; i <= n/2; ++i)

{
if(n%i == 0)
{
flag = 1;
}
}
if (flag == 1)
printf("%d is not a prime number.", n);
else
printf("%d is a prime number.", n);
}

3.4.2. Function with no arguments and with return value

Function with return but no arguments, returns a value but does not accept any argument.
This type of function communicates with the caller function by returning value back to the
caller.
Syntax:
return_type function_name()
{
// Function body
return some_value;
}
Example:
#include <stdio.h>int getInteger();
int main(){
int n, i, flag = 0;

// no argument is passed
n = getInteger();

for(i=2; i<=n/2; ++i)

{
if(n%i==0){
flag = 1;
break;
}
}

if (flag == 1)
printf("%d is not a prime number.", n);
else
printf("%d is a prime number.", n);

return 0;
}
// returns integer entered by the userint getInteger() {
int n;

printf("Enter a positive integer: ");

scanf("%d",&n);

return n;
}

3.4.3. Function with arguments and no return value

Function with no return but with arguments, does not return a value but accepts arguments as
input. For this type of function you must define function return type as void.
Syntax:
void function_name(type arg1, type arg2, ...)
{ // Function body
}
Example

#include <stdio.h>void checkPrimeAndDisplay(int n);

int main(){
int n;

printf("Enter a positive integer: ");

 scanf("%d",&n);

// n is passed to the function

checkPrimeAndDisplay(n);

return 0;
}
// return type is void meaning doesn't return any valuevoid checkPrimeAndDisplay(int n) {
int i, flag = 0;

for(i=2; i <= n/2; ++i)

{
if(n%i == 0){
flag = 1;
break;
}
}
if(flag == 1)
printf("%d is not a prime number.",n);
else
printf("%d is a prime number.", n);
}

3.4.4. Function with arguments and with return value

Function with return and arguments, returns a value and may accept arguments. Since the
function accepts input and returns a result to the caller, hence this type of functions are most
used and best for modular programming.
Syntax:
return_type function_name(type arg1, type arg2, ...)
{
// Function body
return some_variable;
}
Example

#include <stdio.h>int checkPrimeNumber(int n);

int main(){
int n, flag;

printf("Enter a positive integer: ");

scanf("%d",&n);

// n is passed to the checkPrimeNumber() function

// the returned value is assigned to the flag variable
flag = checkPrimeNumber(n);
 if(flag == 1)
printf("%d is not a prime number",n);
else
printf("%d is a prime number",n);

return 0;
}
// int is returned from the functionint checkPrimeNumber(int n){
int i;

for(i=2; i <= n/2; ++i)

{
if(n%i == 0)
return 1;
}

return 0;
}
PASSING ARRAYS TO FUNCTIONS

Arrays can also be arguments of functions. When an array is passed to a function, the address
of the array (address to the first element) is passed to the function called and not the copy of
the complete array. This implies that during its execution the function has the ability to modify
the contents of the array passed as function argument. Therefore, array is not passed to a
function by value.

Example

#include <stdio.h>
void doubleThem(int [], int); /* declaration of function
*/
int main(void)
{
int myInts[10] = {1,2,3,4,5,6,7,8,9,10};
int size=10;
printf(“\n\n The given numbers are :”);
for (i = 0; i < size; i++)
printf(“%d,”,myInts[i]);
doubleThem(myInts,size); /* function call */
printf(“\n\n The double numbers are : ”);
for (i = 0; i < size; i++)
printf(“%d,”,myInts [i]);
return 0;
}
/******* function definition *******/
void doubleThem(int a[], int size)
{
int i;
for(i = 0; i < size; i++)
{
a[i] = 2 * a[i];
}
}

Output
The given numbers are :1, 2, 3, 4, 5, 6, 7,
8, 9, 10,
The double numbers are : 2, 4, 6, 8, 10, 12,
14, 16, 18, 20
 Example - To find the maximum value in an array

#include <stdio.h>
int maximum(int [],int); /* function prototype */
int main(void)
{
int values[5], i, max;
printf(“Enter 5 numbers\n”);
for(i = 0; i < 5; ++i)
scanf(“%d”, &values[i]);
max = maximum(values,5); /* function call */
printf(“\nMaximum value is %d\n”, max);
return 0;
}
/**** function definition ****/
int maximum(int values[], int n)
{
int max_value, i;
max_value = values[0];
for(i = 1; i < n; ++i)
if(values[i] > max_value)
max_value = values[i];
return max_value;
}

Output
Enter 5 numbers
11 15 8 21 7
Maximum value is 21

In the above example, when an array is passed to a function,

➢ Address of the first element (called the base address of an array) is passed which
is passing arguments by address(degenerates to a pointer)
 ➢ A local variable max_value is set to the first element of values, and a for loop is
executed which cycles through each element in values and assigns the maximum
item to max_value.
➢ This number is then passed back by the return statement, and assigned to max in
the main() function.
Note - Array name with an index number as a function argument will only pass that particular
array element’s value, like all other variables, to the function called.

PASSING MULTIDIMENSIONAL ARRAYS TO FUNCTIONS

Multidimensional arrays are also allowed to be passed as arguments to functions. While
specifying the two dimensional array as a formal parameter in a function header, the first
dimension value can be omitted when a multidimensional array is used as a formal parameter in
a function.
For example, the function header could be written as follows:
double yield (double arr[][4], int index);
The function can operate with a two-dimensional array with any value for the first dimension,
but with the second dimension fixed at 4.
Example : Addition and subtraction of two matrices

#include <stdio.h>
#define row 2
#define col 3
void mat_arith(int [][col], int [][col]);/* function prototype */
int main()
{ int a[row][col], b[row][col],i,j;
printf(“\n Enter element of the first matrix.\n”);
for(i=0; i<row; i++) /** Read first matrix elements **/
for(j=0; j<col; j++)
scanf(“%d”,&a[i][j]);
printf(“\n Enter elements of the second matrix.\n”);
for(i=0; i<row; i++) /** Read second matrix elements **/
for(j=0; j<col; j++)
scanf(“%d”,&b[i][j]);
mat_arith(a,b); /** function call **/
}
void mat_arith(int a[][col], int b[][col])
{
int c[row][col],i,j,choice;
printf(“\n For addition enter: 1 \n”)
printf(“For subtraction enter: 2\n”);
printf(“\nEnter your choice:”);
scanf(“%d”,&choice);
for(i=0; i<row; i++)
for(j=0; j<col; j++)
{ if(choice==1)
c[i][j]= a[i][j] + b[i][j];
else if(choice==2)
c[i][j]= a[i][j] - b[i][j];
else
{ printf(“\n Invalid choice. Task not done.”);
return;}
}
printf(“\n The resulting matrix is:\n”);
for(i=0; i<row; i++)
{
for(j=0; j<col; j++)
printf(“%d”, c[i][j]);
printf(“\n\n”);
}
return;
 Output
Enter elements of the second matrix.
1 3 5 7 9 11
For addition enter: 1
For subtraction enter: 2
Enter your choice: 1
The resulting matrix is:
3 7 11
14 17 21

FUNCTIONS WITH STRINGS

Strings are passed to functions in the same way as are one-dimensional arrays.
Some examples involving strings as function arguments is as follows.

program that uses a function to copy one string into

another without using the strcpy()

#include <stdio.h>
void string_copy(char [], char []);
/* function prototype */
int main()
{
char a[100]; /*** source string ***/
char b[100]; /*** destination string ***/
printf(“\n Input source string :”);
scanf(“%[^\n]”,a); /* read input source string */
string_copy(b,a); /* function call */
printf(“\n Destination string : %s\n”,b);
return 0;
}
/*** function definition ***/
void string_copy(char d[], char s[])
{
int i = 0;
printf(“\n Source string : %s\n”,s);
/* copying the string */
for (i = 0; s[i] != ‘\0’; i++)
d[i] = s[i]; /* Copy NUL character to
destination string */
}
RECURSION

Definition - Recursive function is one that calls itself directly or indirectly to solve a smaller
version of its task until a final call which does not require a self-call.
The recursive algorithms will generally consist of an if statement with the following form:
if(this is a base case) then
solve it directly
else
redefine the problem using recursion.

Base case - An instance of a problem the solution of which requires no further recursive calls
is known as a base case. It is a special case whose solution is known. Every recursive algorithm
requires at least one base case in order to be valid.
Needed for implementing recursion
1. Decomposition into smaller problems of same type
2. Recursive calls must diminish problem size
3. Necessity of base case
4. Base case must be reached
5. It acts as a terminating condition. Without an explicitly defined base case, a recursive
function would call itself indefinitely.
6. It is the building block to the complete solution. In a sense, a recursive function
determines its solution from the base case(s) it reaches.
Linear recursion This term is used to describe a recursive function where at most one
recursive call is carried out as part of the execution of a single recursive process.
Non-linear recursion This term is used to describe a recursive function where more than one
recursion can be carried out as part of the execution of a single recursive process.
Mutual recursion In order to check and compile a function call, a compiler must know the
type of the function, the number of parameters, and so on. In direct recursion the function
header, which contains this information, is seen before any call within the function body or
later. In mutual recursion, the functions must be defined in some order. This means that a call
of at least one function must be compiled before its definition is seen.
/*********************************************/
/* Program for computing the Fibonacci number sequence using
recursion. */
/*********************************************/
#include <stdio.h>
#include <stdlib.h>
int fi b(int); /* function prototype */
int main()
{
int i,j;
printf(“\n Enter the number of terms: ”);
scanf(“%d”,&i);
if(i < 0){
printf(“\n Error – Number of terms cannot be negative\n”);
exit(1);
}
printf(“\n Fibonacci sequence for %d terms is:”,i);
for( j=1; j<=i; ++j)
printf(“ %d”,fi b(j)); /* function call to return
jth Fibonacci term*/
return 0;
}
/*********************************************/
/* Recursive function fib() */
/*********************************************/
int fi b(int val)
{
if(val <= 2)
return 1;
else
return(fi b(val - 1) + fi b(val - 2));
}

Output
(a) Enter the number of terms: 6
Fibonacci sequence for 6 terms is: 1 1 2 3 5 8
(b) Enter the number of terms: 4
Fibonacci sequence for 4 terms is: 1 1 2 3
 /*********************************************/
/* Program to find the Greatest Common Divisor using recursion */
/*********************************************/
#include <stdio.h>
int gcd(int, int); /* function prototype */
int main()
{
int i,j;
printf(“\n Enter the numbers :”);
scanf(“%d% d”,&i,&j);
printf(“\n The GCD of %d and %d is\
%d”,i,j,gcd(i,j)); /* function call */
return 0;
}
/*********************************************/
/* Recursive function gcd() */
/*********************************************/
int gcd(int a,int b)
{
int remainder;
remainder = a % b;
if(remainder == 0)
return b;
else
return gcd(b, remainder);
}

Output
Enter the numbers :48 18
The GCD of 48 and 18 is 6

POINTERS
Introduction

• A pointer provides a way of accessing a variable without referring to the variable

directly.
• The mechanism used for this is the address of the variable.
• A program statement can refer to a variable indirectly using the address of the
variable.

Pointer Definition

• A pointer variable is a variable that holds the memory address of another variable
• Put another way, the pointer does not hold a value; instead, it holds the address of
 another variable
• They ‘point’ to a particular point in memory

Declaring a Pointer

• A pointer variable is declared by preceding its name with an asterisk(*).

• The syntax for declaring a pointer variable is
datatype *pointer_variable;
• datatype is the type of data that the pointer is allowed to hold the address of
• pointer_variable is the pointer variable name that is used to refer to the address of a
variable of type datatype.

Example for pointer declaration

• An example of a pointer declaration would be
char *ptr;
• The above declaration should be evaluated as:
– ptr is a pointer to char type data.
– char is not the data type of ptr.
– ptr is an identifier of type pointer and
– char is a data specifier that is used to indicate what type of data is at the
memory address that ptr is holding.
• Consider the following declaration.
int *a;
• The above declaration indicates that a is a pointer type variable that points to int type
data. That is, the int indicates that the pointer variable is intended to store the address of
an integer variable. Such a pointer is said to ‘point to’ an integer.
float *t;
• The above declaration represents the fact that t is a pointer type variable that points to
float type data
• Some declarations are listed
Example Program
Initializing Pointers

• Unlike a simple variable that stores a value, a pointer must be initialized with a
specified address prior to its use.
• The syntax for initializing a pointer variable is
datatype *pointer_variable = &variable_name ;
Example Program

• The following program shows how to use the address operator to assign the address of a
variable to a pointer.
• This program also demonstrates that the value of a pointer is the same as the
address to which the pointer points.
#include <stdio.h>
int main()
{
int i = 5;
int *ptr = &i;
printf(“\nThe address of i using &num is %p”, &i);
printf(“\nThe address of i using Ptr is %p”, ptr);
return 0;
}

Any number of pointers can point to the same address. For example, we could declare p,
q, and r as integer pointers and set all of them to point to i as shown here.
int i=3;
int *p, *q,
*r; p = &i;
q=
&i; r =
p;
 Printing pointer value

A pointer variable contains a memory address that points to another variable. To print the
memory address stored in pointers and non-pointer variables using the
%p conversion specifier is used
#include <stdio.h> Output: p = 0022FF2C
int main(void)
{
int a=10, *p;
p=&a;
printf(“\n p = %p”, p);
return 0;
}

Indirection Operator and Dereferencing

• The primary use of a pointer is to access and, if appropriate, change the value of the
variable that the pointer is pointing to
• The other pointer operator available in C is ‘*’, called the ‘value at address’ operator.
• It returns the value stored at a particular address
• The value at address operator is also called indirection operator or dereference
operator

In the following program, the value of the integer variable num is changed twice. #include
<stdio.h>
int main()
{
int num = 5;
int *iPtr = &num;
printf(“\n The value of num is %d”, num);
 num = 10;
printf(“\n The value of num after num = 10 is: %d”, num);
*iPtr = 15;
printf(“\n The value of num after *iPtr = 15 is: %d”, num); return
0;
}

• The second change should be familiar, by the direct assignment of a value to num,
such as num=10
• However, the third change is accomplished in a new way, by using the indirection
operator
• *iPtr = 15;
• The indirection operator is an asterisk, the same asterisk that is used to declare the
pointer or to perform multiplication
• However, in this statement the asterisk is not being used in a declaration or to
perform multiplication

Addition Using Pointers

#include <stdio.h>
int main()
{
int a,b,c;
int *pa,*pb,*pc;
pa=&a;
pb=&b;
pc=&c;
printf(“\n ENTER THE FIRST NUMBER:”);
scanf(“%d”,pa);
printf(“\n ENTER THE SECOND NUMBER:”);
scanf(“%d”,pb);
*pc=*pa+*pb;
printf(“\n SUM IS %d”,*pc);
return 0;
}
VOID POINTER

• A void pointer is a special type of pointer

• It can point to any data type, from an integer value or a float to a string of characters
• The limitation is that the pointed data cannot be referenced directly
• type casting or assignment must be used to turn the void pointer to a pointer of a
concrete data type to which we can refer.
Example:
#include <stdio.h>
int main()
{
int a=5,
double b=3.1415;
void *vp;
vp=&a;
printf(“\n a= %d”, *((int *)vp));
vp=&b;
printf(“\n a= %d”, *((double *)vp));
return 0;
}

NULL POINTER

• A null pointer is a special pointer that points nowhere

• That is, no other valid pointer to any other variable or array cell or anything else will
ever be equal to a null pointer
• The null pointer in the program is assigning with a keyword NULL, which is defined by
several standard header files, including <stdio.h>, <stdlib.h>, and <string.h>
 Example

#include <stdio.h>
int main()
{
int *p;
p = NULL;
printf(“\n The value of p is %u”, p);
return 0;
}

Passing pointers to functions

C programming allows passing a pointer to a function. To do so, simply declare the function
parameter as a pointer type

#include <stdio.h>
void salaryhike(int *var, int b)
{
*var = *var+b;
}
int main()
{
int salary=0, bonus=0;
printf("Enter the employee current salary:");
scanf("%d", &salary);
printf("Enter bonus:"); scanf("%d",
&bonus); salaryhike(&salary,
bonus); printf("Final salary: %d",
salary); return 0;

}
Output Enter the employee current salary:10000
Enter bonus:2000
Final salary: 12000
 Pointers and one dimensional arrays

• Pointers and arrays are inseparably related, but they are not synonymous.
• An array is a non-empty set of sequentially indexed elements having the same type of
data. Each element of an array has a unique identifying index number.
• The array a is laid out in memory as a contiguous block, as shown. int
a[]={10, 20, 30, 40, 50};

Elements of array are stored in the successive increasing locations of memory. For example, if the
array starts at memory location 2147478270 (considering a 32-bit machine), then with the
assumed size of an integer as four bytes, the fi rst element is stored at location 2147478270, the
second element at location 2147478274, and so on.

• Array notation is a form of pointer notation.

• The name of an array is the beginning address of the array, called the base address of
the array.
• The array name is referred to as an address constant.
• Both array and &array would give the base address of the array, but the only difference
is under ANSI/ISO Standard C, &array yields a pointer, of type pointer to- array of-the
data type to the entire array.

Example 1

#include <stdio.h>
int main()
{
int a[]={10, 20, 30, 40, 50};
printf(“%u %u”, a, &a[0]);
return 0;
}

Output:

2147478270 2147478270
• With the name of the array actually being a constant that represents a memory address,
the name of the array can be used as a pointer and an integer value can be used to
represent an offset from the base address.

• An element of the array a is addressed as a[i] and the address of the ith element of the
array a is given by &a[i]=a + i size of the type pointed to by a.

• The expression a + i (with integer i) means the address of the ith element beyond the
one a points to. This is known as scaling.

• As indirection operator ‘*’ implies value at address, a[i] is equivalent to *(a+i).

Example 2

#include <stdio.h>
int main()
{
int a[]={10, 20, 30, 40, 50};
int i;
for(i=0;i<5;i++)
{
printf("\n %d", a[i]);
printf("\n %d",*(a+i));
printf("\n %d", &a[i]);
}
return 0;
}

Output:

10
10
1011568592
20
20
1011568596
30
30
1011568600
40
40
1011568604
 50
50
1011568608

• All the following four expressions are the same when their addresses are
considered.
a[i], *(a + i), *(i + a), i[a]
• In the expression a[i], i must be an integer. The other may either be an array name or a
pointer. For any one-dimensional array a and integer i, the following relationships are
always true.

1. &a[0] == a
2. &a[i] == a + i
3. a[i] == *(a + i)
4. (&a[i] - &a[j]) == (i - j)

A pointer variable (of the appropriate type) can also be used to initialize or point to the fi rst
element of the array. Then it can also be used as above.

Example 3

One can define a pointer of the same type as the elements of the array and can assign it the
address of any element of the array and use it to access the array elements. . In fact, one may add
an integer value to it.
Pointers and arrays are so closely related that their notation can be interchanged such that the
following terms are identical if p contains the value of a.

• a[i]

• *(a + i)

• *(p + i)

• p[i]

where i=0,1,2,...(N–1). N is the size of the array.

This equivalence does not mean that arrays and pointers are the same (they are, in fact, quite
different) but that they can be used in related ways, and that certain operations may be used
between them. These operations are as follows.

• The first such operation is that it is possible to (apparently) assign an array to a

pointer.

int a[10];

int *p;

p = a;

C defines the result of this assignment to be that p receives a pointer to the first element of
a. In otherwords,

p = &a[0];

• The second aspect of the equivalence is that the array subscripting notation [i] can be
applied on pointers,too. p[3] can be written as *(p + 3).

The pointer to an array does not always point to the first element of the array. It can point to any
element of the array. For example,

int a[]={10,20,30,40,50};

int *p;

p = a + 3;

can also be written as follows p

= &a[0] + 3;
which, in turn, gives the same result as p

= &a[3];

Operations on Pointers

If p is declared as a pointer variable of any type and it has been initialized properly, then,
just like a simple variable,any operation can be performed with *p.
Because *implies value at address, working with *p means working with the variable
whose address is currently held by p.

The only valid operations on pointers are as follows.

• Assignment of pointers to the same type of pointers.

• Adding or subtracting a pointer and an integer.
• Subtracting or comparing two pointers.
• Incrementing or decrementing the pointers.
• Assigning the value 0 to the pointer variable and comparing 0 with the pointer.

Assignment operator
Pointers with the assignment operators can be used if the following conditions are met.

• The left-hand operand is a pointer and the right-hand operand is a null pointer
constant.

• One operand is a pointer to an object of incompatible type and the other is a pointer to
void.

• Both the operands are pointers to compatible types.

Example

#include <stdio.h>
int main()
{
int i=5;
int *ip;
void *vp;
ip = &i;
vp = ip;
//printf(“\n *vp= %d”,*vp); —————— ERROR
ip = vp;
printf(“\n *ip= %d”,*ip);
return 0;
}
This program gives an error in the first printf statement stating ‘not an allowed type’ because
no type is associated with a void pointer.

• The right version of this program is as follows.

#include <stdio.h>
int main()
{
int i=5;
int *ip;
void *vp;
ip = &i;
vp = ip;
printf(“\n *vp= %d”,*((int *)vp));
ip = vp;
printf(“\n *ip= %d”,*ip);
return 0;
}
Output:
*vp=5
*ip=5

Addition or Subtraction with Integers

• a ‘+’ between a pointer and an integer does the same offset computation as
explained earlier, but leaves the result as a pointer.

• We can add a value to the pointer variable. The formula of adding value to
pointer is given below:

new_address= current_address + (number * size_of(data type))

Example

include<stdio.h>
int main()
{
int number=50;
int *p;//pointer to int
p=&number; //stores the address of number variable
printf("Address of p variable is %u \n",p);
p=p+3; //adding 3 to pointer variable
printf("After adding 3: Address of p variable is %u \n",p);
return 0;
}

Output:

Address of p variable is 3214864300

After adding 3: Address of p variable is 3214864312

• As you can see, the address of p is 3214864300. But after adding 3 with p variable, it is
3214864312, i.e., 4*3=12 increment. Since we are using 64-bit architecture, it increments
12.

Consider the following two versions of same program.

 (a)

#include <stdio.h>
int main(void)
{
int a[] = {10, 12, 6, 7, 2};
int i;
int sum = 0;
for(i=0; i<5; i++)
{
sum += a[i];
}
printf(“%d\n”, sum);
return 0;
}

(b)
#include <stdio.h>
int main(void)
{
int a[] = {10, 12, 6, 7, 2};
int i;
int sum = 0; for(i=0;
i<5; i++)
{
sum += *(a + i);
}
printf(“%d\n”, sum);
return 0;
}

• Therefore, expressions can add (or subtract, which is equivalent to adding negative
values) integral values to the value of a pointer to any object type. The result has the type
of the pointer and if n is added, then the result points n array elements away from the
pointer.

Typical string-processing function.

• Pointer arithmetic and dereferencing are used to search for various

characters or patterns
 Using p++

• If p is a pointer to an element in an array, then (p+1) points to the next element in the
array.
• The statement p++ can be used to step a pointer over the elements in an array.

Example (sum of n numbers)

#include <stdio.h>
int main(void)
{
int a[] = {10, 12, 6, 7, 2};
int i;
int sum = 0;
int *p;
p = a;
for(i=0; i<5; i++)
{
sum += *p;
p++;
}
printf(“%d\n”, sum);
return 0;
 }

It is possible to traverse an array starting from a pointer to any element in the array.
Consider the following program.

#include <stdio.h>
#define N 5
int main()
{
float arr[N], *ptr;
int *iptr, a[N], i;
/* initialize */
for(i = 0; i < N; i++)
{
arr[i] = 0.3;
a[i] = 1;
}
/* initialize ptr to point to element arr[3] */ ptr =
&arr[3];
*ptr = 1.0; /* arr[3] = 1.0 */
*(ptr - 1) = 0.9; /* arr[2] = .9 */
*(ptr + 1) = 1.1; /* arr[4] = 1.1 */
/* initialize iptr in the same way */
iptr = &a[3];
*iptr = 0;
*(iptr - 1) = -1;
*(iptr + 1) = 2; for(i
= 0; i < N; i++)
{
printf(“arr[%d] = %f”, i, *(arr + 1));
printf(“a[%d] = %d\n”, i, a[i]);
return 0;
}
}

Output:

arr[0] = 0.300000 a[0] = 1

arr[1] = 0.300000 a[1] = 1

 arr[2] = 0.900000 a[2] = -1

arr[3] = 1.000000 a[3] = 0

arr[4] = 1.100000 a[4] = 2

Subtraction of pointers with integers

• Like pointer addition, we can subtract a value from the pointer variable. Subtracting any
number from a pointer will give an address. The formula of subtracting value from the
pointer variable is given below:

new_address= current_address (number * size_of(data type))

Example

#include<stdio.h>
int main()
{
int number=50;
int *p; //pointer to int
p=&number; //stores the address of number variable printf("Address
of p variable is %u \n",p);
p=p-3; //subtracting 3 from pointer variable
printf("After subtracting 3: Address of p variable is %u \n",p);
return 0;
}
Output:
Address of p variable is 3214864300
After subtracting 3: Address of p variable is 3214864288

Increment operator
 Example

#include <stdio.h>
int main()
{
int A[] = {10, 20, 30, 40, 50};
int *p, i; p
= A;
printf(“*p : %i\n\n”, *p); i =
*(p++);
printf(“i is: %i\n”, i);
printf(“*p is: %i\n\n”, *p); i =
(*p)++;
printf(“i is: %i\n”, i);
printf(“*p is: %i\n\n”, *p); i =
*(++p);
printf(“i is: %i\n”, i);
printf(“*p is: %i\n\n”, *p); i =
++(*p);
printf(“i is: %i\n”, i);
printf(“*p is: %i\n\n”, *p);
return 0;
}
Output:

*p : 10 i
is : 10
*p is: 20
i is: 20
*p is: 21
i is: 30
*p is: 30
i is: 31
*p is: 31

Decrement operator

#include <stdio.h>
int main(void)
{
int a[] = {10, 20, 30, 40, 50};
int i, *p;
p=a+4;
for(i=4; i>=0; i––)
printf(“%d\n”, *(p-i));
return 0;
}
Output:

10
20
30
40
50

The above code may be replaced by the following code. #include

<stdio.h>
int main(void)
{
int a[] = {10, 12, 6, 7, 2};
int i, *p;
p=a+4;
for(i=4; i>=0; i––)
printf(“%d\n”, p[-i]);
return 0;
}
p[–i] is equivalent to *(p–i). Initially p points to the last element. At the beginning, i=4, p-i
evaluates as p–i*sizeof(int)= p–16 (in a 32-bit machine) or =p–8(in a 16-bit machine). Now p-i
gives the address of the first element of the array. p[–i], which is equivalent to, *(p–i), prints the
first element of the array

Subtraction of Pointers

For example, one might write p2

= p1 + 3;

Applying a little algebra,

p2 - p1 = 3

Here both p1 and p2 are pointers pointing to the elements of the same array. From this it can be
concluded that the two pointers are subtracted, as long as they point into the same array.

Example

#include <stdio.h>
int main()
{
double a[2],*p,*q;
p=a;
q=p+1;
printf(“%d\n”,q – p);
return 0;
}
Output:

Given two pointers p and q of the same type, the difference p – q is an integer k such that adding k
to q yields p.

To print the number of bytes resulting from q-p, each pointer may be typecast.

#include <stdio.h>
int main()
{
double a[2],*p,*q;
p=a;
q=p+1;
printf(“%d\n”,(int)q-(int)p);
return 0;
}
Output:

Comparing Pointers

• C allows pointers to be compared with each other. If two pointers compare equal to each
other, then they point to the same thing, whether it is an object or the non- existent
element of the end of an array.

• If two pointers point to the same thing, then they compare equal to each other.

• The relational operators >, <=, and so on give the result that would be expected if the
pointers point to the same array: if one pointer compares less than another, then it points
nearer to the front of the array.

Example

#include <stdio.h>
int main(void)
{
int a[] = {10, 20, 30, 40, 50};
int i, *p;
for(p=a; p<=a+4; p++)
printf(“%d\n”, *p);
return 0;
}

Output:

10
20
30
40
50
The following program will print the line in reverse order..

#include <stdio.h>
#include <string.h>
int main()
{
char a[50];
void reverse(char *);
printf(“\n Enter the string:”);
gets(a);
reverse(a);
printf(“\nAfter reversing the string is :\n”);
puts(a);
return 0;
}
void reverse(char *string)
{
char *lp = string; /* left pointer */ char
*rp = &string[strlen(string)-1];
/* right pointer */
char tmp; while(lp
< rp)
{
tmp = *lp;
*lp = *rp;
*rp = tmp;
lp++; rp––;
}

}
Output:
Enter the string:manas After
reversing the string is: sanam
 Pointer arithmetic summary

DYNAMIC MEMORY ALLOCATION

• It is the required memory that is allocated at run-time (at the time of execution).

• The area from where the application gets dynamic memory is called heap.

• The heap starts at the end of the data segment and grows against the bottom of the stack.

• C provides access to the heap features through library functions that any C code can call.

• To allocate memory dynamically, library functions

are malloc(), calloc(), realloc() and free() are used.

• These functions are defined in the <stdlib.h> header file.

C malloc()

• The name "malloc" stands for memory allocation.

• The malloc() function reserves a block of memory of the specified number of bytes.
And, it returns a pointer of void which can be casted into pointers of any form.

• Syntax of malloc()
 ptr = (castType*) malloc(size);

ptr = (float*) malloc(100 * sizeof(float));

The above statement allocates 400 bytes of memory. It's because the size of float is 4
bytes. And, the pointer ptr holds the address of the first byte in the allocated memory.

C calloc()

• The name "calloc" stands for contiguous allocation.

• The malloc() function allocates memory and leaves the memory uninitialized.
Whereas, the calloc() function allocates memory and initializes all bits to zero

• Syntax of calloc()

ptr = (castType*)calloc(n, size);

ptr = (float*) calloc(25, sizeof(float));

The above statement allocates contiguous space in memory for 25 elements of type float.

C free()

Dynamically allocated memory created with either calloc() or malloc() doesn't get freed on their
own. You must explicitly use free() to release the space.

• Syntax of free()

free(ptr);

This statement frees the space allocated in the memory pointed by ptr.

C realloc()

If the dynamically allocated memory is insufficient or more than required, you can
change the size of previously allocated memory using the realloc() function.

• Syntax of realloc()

ptr = realloc(ptr, x);

Here, ptr is reallocated with a new size x.

Example 1: malloc() and free()

Program to calculate the sum of n numbers entered by the user

#include <stdio.h>
#include <stdlib.h>
int main()
{
int n, i, *ptr, sum = 0;
printf("Enter number of elements: ");
scanf("%d", &n);
ptr = (int*) malloc(n * sizeof(int));

// if memory cannot be allocated

if(ptr == NULL)
{
printf("Error! memory not allocated.");
exit(0);
}

printf("Enter elements: ");

for(i = 0; i < n; ++i)
{
scanf("%d", ptr + i);
sum += *(ptr + i);
}
printf("Sum = %d", sum);

// deallocating the memory

free(ptr);
return 0;
}
Example 2: calloc() and free()

// Program to calculate the sum of n numbers entered by the user #include

<stdio.h>
#include <stdlib.h>
int main()
{
int n, i, *ptr, sum = 0;
 printf("Enter number of elements: ");
scanf("%d", &n);
ptr = (int*) calloc(n, sizeof(int));
if(ptr == NULL)
{
printf("Error! memory not allocated.");
exit(0);
}
printf("Enter elements: ");

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

{
scanf("%d", ptr + i);
sum += *(ptr + i);
}
printf("Sum = %d", sum);
free(ptr);
return 0;
}

Example 3: realloc()

#include <stdio.h>
#include <stdlib.h>
int main()
{
int *ptr, i , n1, n2;
printf("Enter size: ");
scanf("%d", &n1);
ptr = (int*) malloc(n1 * sizeof(int)); printf("Addresses
of previously allocated memory: "); for(i = 0; i < n1; ++i)
printf("%u\n",ptr + i);
printf("\nEnter the new size: ");
scanf("%d", &n2);
// rellocating the memory
ptr = realloc(ptr, n2 * sizeof(int)); printf("Addresses
of newly allocated memory: "); for(i = 0; i < n2;
++i)
printf("%u\n", ptr + i);
 free(ptr);
return 0;
}

Output:
Enter size: 2
Addresses of previously allocated memory:26855472
26855476
Enter the new size: 4
Addresses of newly allocated memory:26855472
26855476
26855480
26855484

The four functions of interest are as follows:

• void* malloc(size_t size): Request a contiguous
block of memory of the given size in the heap. malloc() returns a pointer to the heap block or
NULL if the request is not satisfied.
• calloc(): works like malloc, but initializes the memory to zero if possible. The
prototype is
void * calloc(size_t count, size_t eltsize)
This function allocates a block long enough to contain an array of count elements, each of size
eltsize. Its contents are cleared to zero before calloc returns.
• void free(void* block): free() takes a pointer to a heap block earlier allocated by malloc()
and returns that block to the heap for reuse.
• void* realloc(void* block, size_t size): Take an existing heap block and try to reallocate it
to a heap block of the given size which may be larger or smaller than the original size of the
block