# Pointers to Functions A+ A  A-

How to declare a pointer to a function?
Syntax: returntype_of_function (*pointer variable)(List of arguments);

For example:
int (*p)(int,int); can be interpreted as p is a pointer to function which takes two integers as argument and returntype is integer.

How to make a pointer to a function?
Syntax:
pointer_variable=function_name_without_parantheses;

For Example:
p=test;
can be read as p is a pointer to function test.

How to call a function using pointer?
Syntax:

pointer_variable(ist of arguments);
OR

(*pointer_variable)(List of arguments);

The following program illustrates pointer to function

```int getc()
{
return 10;
}
void put(int a)
{
printf(“%d”,a);
}
void main()
{
int k;
int (*p)(); /*You can write void *p();*/
void (*q)(int); /*You can write void *q(int);*/
p=get; q=put; k=p(); q(k);
}```

NOTE:
(i) In C every function is stored into physical memory location and entry point of that function address is stored into function name. If you assign a pointer to to the function then the base address of the function is copied into the pointer. Using this control is shifting from calling function to called function.
(ii) By default all functions are global, we can access from wherever we want. So there is no
such significance to make a pointer to function.

In C, a function itself is not a variable, but it is possible to define pointers to functions, which can
be assigned, placed in arrays, passed to functions, returned by functions, and so on. We will illustrate this by modifying the sorting procedure written earlier in this chapter so that if the optional argument -n is given, it will sort the input lines numerically instead of lexicographically.

A sort often consists of three parts – a comparison that determines the ordering of any pair of objects, an exchange that reverses their order, and a sorting algorithm that makes comparisons and exchanges until the objects are in order. The sorting algorithm is independent of the comparison and exchange operations, so by passing different comparison and exchange functions to it, we can arrange to sort by different criteria. This is the approach taken in our new sort.

Lexicographic comparison of two lines is done by strcmp, as before; we will also need a routine numcmpthat compares two lines on the basis of numeric value and returns the same kind of condition indication as strcmpdoes. These functions are declared ahead of main and a pointer to the appropriate one is passed to qsort. We have skimped on error processing for arguments, so as to concentrate on the main issues.

```#include <stdio.h>
#include
#define MAXLINES 5000 /* max #lines to be sorted */
char *lineptr[MAXLINES]; /* pointers to text lines */
void writelines(char *lineptr[], intnlines);
void qsort(void *lineptr[], int left, int right, int (*comp)(void *, void *));
int numcmp(char *, char *);
/* sort input lines */
main(intargc, char *argv[])
{
intnlines; /* number of input lines read */
int numeric = 0; /* 1 if numeric sort */
if (argc> 1 &&strcmp(argv, "-n") == 0)
numeric = 1;
if ((nlines = readlines(lineptr, MAXLINES)) >= 0)
{
qsort((void**) lineptr, 0, nlines-1,
(int (*)(void*,void*))(numeric ? numcmp : strcmp));
writelines(lineptr, nlines);
return 0;
}
else
{
printf("input too big to sort\n");
return 1;
}
}```

In the call to qsort, strcmpand numcmpare addresses of functions. Since they are known to be functions, the & is not necessary, in the same way that it is not needed before an array name. We have written qsortso it can process any data type, not just character strings. As indicated by the function prototype, qsortexpects an array of pointers, two integers, and a function with two pointer arguments. The generic pointer type void * is used for the pointer arguments. Any pointer can be cast to void * and back again without loss of information, so we can call qsortby
casting arguments to void *. The elaborate cast of the function argument casts the arguments of the comparison function. These will generally have no effect on actual representation, but assure the compiler that all is well.

```void qsort(void *v[], int left, int right,
int (*comp)(void *, void *))
{
inti, last;
void swap(void *v[], int, int);
if (left >= right) /* do nothing if array contains */
return; /* fewer than two elements */
swap(v, left, (left + right)/2);
last = left;
for (i = left+1; i<= right; i++)
if ((*comp)(v[i], v[left]) < 0)
swap(v, ++last, i);
swap(v, left, last);
qsort(v, left, last-1, comp);
qsort(v, last+1, right, comp);
}

```

The declarations should be studied with some care. The fourth parameter of qsortis int (*comp)(void *, void *)
which says that comp is a pointer to a function that has two void * arguments and returns an int.
The use of comp in the line if ((*comp)(v[i], v[left]) < 0) is consistent with the declaration: comp is a pointer to a function, *comp is the function, and (*comp)(v[i], v[left]) is the call to it. The parentheses are needed so the components are correctly associated; without them, int *comp(void *, void *) says that comp is a function returning a pointer to an int, which is very different. We have already shown strcmp, which compares two strings. Here is numcmp, which compares two strings on a leading numeric value, computed by calling atof:

```#include
/* numcmp: compare s1 and s2 numerically */
intnumcmp(char *s1, char *s2)
{ double v1, v2;
v1 = atof(s1);
v2 = atof(s2);
if (v1 < v2) return -1; else if (v1 > v2)
return 1;
else
return 0;
}
The swap function, which exchanges two pointers, is as follows
void swap(void *v[], inti, int j;)
{ void *temp;
temp = v[i];
v[i] = v[j];
v[j] = temp;
}

```

Try Now – Programming In C MCQs