0% found this document useful (0 votes)

19 views28 pages

RDoc 38064

The document explains function pointers in programming, detailing how to declare, assign, and call functions using pointers. It also covers recursion, providing examples such as calculating factorials and finding the maximum in an array. Key concepts include the importance of base conditions in recursion and the distinction between function pointers and regular function declarations.

Uploaded by

Krishna singh

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

19 views28 pages

RDoc 38064

Uploaded by

Krishna singh

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 28

Pointers to functions

A pointer to a function points to the address of the executable code of

the function. You can use pointers to call functions and to pass
functions as arguments to other functions. You cannot perform
pointer arithmetic on pointers to functions.

Syntax of function pointer

1. return type (*ptr_name)(type1, type2…);

For example:

1. int (*ip) (int);

In the above declaration, *ip is a pointer that points to a function which returns
an int value and accepts an integer value as an argument.

1. float (*fp) (float);

In the above declaration, *fp is a pointer that points to a function that returns
a float value and accepts a float value as an argument.
We can observe that the declaration of a function is similar to the declaration
of a function pointer except that the pointer is preceded by a '*'. So, in the
above declaration, fp is declared as a function rather than a pointer.

Till now, we have learnt how to declare the function pointer. Our next step is to
assign the address of a function to the function pointer.

1. float (*fp) (int , int); // Declaration of a function pointer.

2. float func( int , int ); // Declaration of function.
3. fp = func; // Assigning address of func to the fp pointer.

In the above declaration, 'fp' pointer contains the address of

the 'func' function.

Calling a function through a function pointer

We already know how to call a function in the usual way. Now, we will see how to
call a function using a function pointer.

Suppose we declare a function as given below:

1. float func(int , int); // Declaration of a function.

Calling an above function using a usual way is given below:

1. result = func(a , b); // Calling a function using usual ways.

Calling a function using a function pointer is given below:

1. result = (*fp)( a , b); // Calling a function using function pointer.

1. result = fp(a , b); // Calling a function using function pointer, and indirecti
on operator can be removed.

The effect of calling a function by its name or function pointer is the same. If we
are using the function pointer, we can omit the indirection operator as we did
in the second case. Still, we use the indirection operator as it makes it clear to
the user that we are using a function pointer.

1. #include <stdio.h>
2. int add(int,int);
3. int main()
4. {
5. int a,b;
6. int (*ip)(int,int);
7. int result;
8. printf("Enter the values of a and b : ");
9. scanf("%d %d",&a,&b);
10. ip=add;
11. result=(*ip)(a,b);
12. printf("Value after addition is : %d",result);
13. return 0;
14. }
15. int add(int a,int b)
16. {
17. int c=a+b;
18. return c;
19. }

Output
The type of a pointer to a function is based on both the return type
and parameter types of the function.

A declaration of a pointer to a function must have the pointer name in

parentheses. Function parameters have precedence over pointers in
declarations, so parentheses are required to alter the precedence and
declare a pointer to a function. Without them, the compiler interprets
the declaration as a function that returns a pointer to a specified
return type. For example:
int *f(int a); /* function f returning an int* */
int (*g)(int a); /* pointer g to a function returning an int */

In the first declaration, f is interpreted as a function that takes

an int as argument, and returns a pointer to an int. In the second
declaration, g is interpreted as a pointer to a function that takes
an int argument and that returns an int.

You can use a trailing return type in the declaration or definition of a

pointer to a function. For example:
auto(*fp)()->int;
In this example, fp is a pointer to a function that returns int. You can
rewrite the declaration of fp without using a trailing return type as int
(*fp)(void).
Recursion
 A process by which a function calls itself repeatedly
 Either directly.
 X calls X
 Or cyclically in a chain.
 X calls Y, and Y calls X

 Used for repetitive computations in which each

action is stated in terms of a previous result
fact(n) = n * fact (n-1)

1
 For a problem to be written in recursive form, two
conditions are to be satisfied:
 It should be possible to express the problem in
recursive form
 Solution of the problem in terms of solution of the same
problem on smaller sized data
 The problem statement must include a
stopping/terminating condition
 The direct solution of the problem for a small enough
size

Stopping/Terminating
fact(n) = 1, if n = 0
condition
= n * fact(n-1), if n > 0
Recursive definition

3
 Examples:

 Factorial:
fact(0) = 1
fact(n) = n * fact(n-1), if n > 0
 GCD:
gcd (m, m) = m
gcd (m, n) = gcd (m%n, n), if m > n
gcd (m, n) = gcd (n, n%m), if m < n
 Fibonacci series (1,1,2,3,5,8,13,21,….)
fib (0) = 1
fib (1) = 1
fib (n) = fib (n-1) + fib (n-2), if n > 1
4
Factorial
long int fact (int n)
{
if (n == 1)
return (1);
else
return (n * fact(n-1));
}

5
Factorial Execution

long int fact (int n)

{
if (n = = 1) return (1);
else return (n * fact(n-1));
}

6
Factorial Execution
fact(4)