Function Pointer in C++

As we know that pointers are used to point some variables; similarly, the function pointer is a pointer used to point functions. It is basically used to store the address of a function. We can call the function by using the function pointer, or we can also pass the pointer to another function as a parameter.

They are mainly useful for event-driven applications, callbacks, and even for storing the functions in arrays.

What is the address of a function?

Computer only understands the low-level language, i.e., binary form. The program we write in C++ is always in high-level language, so to convert the program into binary form, we use compiler. Compiler is a program that converts source code into an executable file. This executable file gets stored in RAM. The CPU starts the execution from the main() method, and it reads the copy in RAM but not the original file.

All the functions and machine code instructions are data. This data is a bunch of bytes, and all these bytes have some address in RAM. The function pointer contains RAM address of the first instruction of a function.

Syntax for Declaration

The following is the syntax for the declaration of a function pointer:

The above syntax is the function declaration. As functions are not simple as variables, but C++ is a type safe, so function pointers have return type and parameter list. In the above syntax, we first supply the return type, and then the name of the pointer, i.e., FuncPtr which is surrounded by the brackets and preceded by the pointer symbol, i.e., (*). After this, we have supplied the parameter list (int,int). The above function pointer can point to any function which takes two integer parameters and returns integer type value.

Address of a function

We can get the address of a function very easily. We just need to mention the name of the function, we do not need to call the function.

Let's illustrate through an example.

#include <iostream>
using namespace std;
int main()
{
  std::cout << "Address of a main() function is : " <<&main<< std::endl;
  return 0;
}

In the above program, we are displaying the address of a main() function. To print the address of a main() function, we have just mentioned the name of the function, there is no bracket not parameters. Therefore, the name of the function by itself without any brackets or parameters means the address of a function.

We can use the alternate way to print the address of a function, i.e., &main.

Calling a function indirectly

We can call the function with the help of a function pointer by simply using the name of the function pointer. The syntax of calling the function through the function pointer would be similar as we do the calling of the function normally.

Let's understand this scenario through an example.

#include <iostream>
using namespace std;
int add(int a , int b)
{
    return a+b;
}
int main()
{
 int (*funcptr)(int,int);  // function pointer declaration
 funcptr=add; // funcptr is pointing to the add function
 int sum=funcptr(5,5);
 std::cout << "value of sum is :" <<sum<< std::endl;
  return 0;
}

In the above program, we declare the function pointer, i.e., int (*funcptr)(int,int) and then we store the address of add() function in funcptr. This implies that funcptr contains the address of add() function. Now, we can call the add() function by using funcptr. The statement funcptr(5,5) calls the add() function, and the result of add() function gets stored in sum variable.

Output:

Let's look at another example of function pointer.

#include <iostream>
using namespace std;
void printname(char *name)
{
    std::cout << "Name is :" <<name<< std::endl;
}

int main()
{
    char s[20];  // array declaration
    void (*ptr)(char*);  // function pointer declaration
    ptr=printname;  // storing the address of printname in ptr.
    std::cout << "Enter the name of the person: " << std::endl;
    cin>>s;
    cout<<s;
    ptr(s);  // calling printname() function
   return 0;
}

In the above program, we define the function printname() which contains the char pointer as a parameter. We declare the function pointer, i.e., void (*ptr)(char*). The statement ptr=printname means that we are assigning the address of printname() function to ptr. Now, we can call the printname() function by using the statement ptr(s).

Output:

Passing a function pointer as a parameter

The function pointer can be passed as a parameter to another function.

Let's understand through an example.

#include <iostream>
using namespace std;
void func1()
{
    cout<<"func1 is called";
}
void func2(void (*funcptr)())
{
    funcptr();
}
int main()
{
  func2(func1);
  return 0;
}

In the above code, the func2() function takes the function pointer as a parameter. The main() method calls the func2() function in which the address of func1() is passed. In this way, the func2() function is calling the func1() indirectly.

Output: