Function Pointer

Dear helper,

  Suppose I have the following code:

int function1(int);

int main(void) {
  int (*fPtr)(int) = function1;
  return 0;

  Why can I call the function using pointer to function in two ways?

 - (*fPtr)(5);
 - fPtr(5);

  I have read a book that says both of the statements are the same. I am not so clear why they are the same? Please explain me.

Thank you in advance,

Who is Participating?
I wear a lot of hats...

"The solutions and answers provided on Experts Exchange have been extremely helpful to me over the last few years. I wear a lot of hats - Developer, Database Administrator, Help Desk, etc., so I know a lot of things but not a lot about one thing. Experts Exchange gives me answers from people who do know a lot about one thing, in a easy to use platform." -Todd S.

So what is a pointer? A pointer is a way to get at another object. Essentially it is a way to grab an instance of an object and then either pass that instance a message or retreive some data from that object. A pointer is actually just an address of where an instance is held in memory.

Some piece of your program can either possess an instance of an object, or know where an instance of an object is. An instance of an object is a chunk of memory that is big enough to store all the member data of that object. A pointer is an address that explains how to get to where the instance is actually held in memory.
There isn't any logical reason.  It's just a decision the language designers made.  The first form is consistent with the rest of the language; the second form was probably just added for convenience, since there isn't much you can do with a function pointer other than call the function it addresses.

Dear Dina,
I also read the same thing in one book they are saying that since it is function pointer.

First they allowed syntax (fPtr)(5);

People started commenting that fptr is pointer it should be de-referenced then they given another syntax

CompTIA Network+

Prepare for the CompTIA Network+ exam by learning how to troubleshoot, configure, and manage both wired and wireless networks.

When using a pointer to the method of a class, you *need* to dereference it.

Class Test
  int F1(){ return 1;}
  int F2() { return 2;}

int main()
   int (Test::*pFunction)() = 0; // Initialise pointer to NULL

   Test* ptr = new Test();

   pFunction = Test::F1;

   /* Note if the below line was ptr->pFunction, the compiler would complain stating that             pFunction is not a member of the Test class, which it is quite right about !
   cout << (ptr->*pFunction)() << endl;
   return 0;

This code should compile; have not got one on me (on me ?!?).  Basically if you do not dereference pFunction the compiler wont be too happy.  But at least it wont be a linker or runtime error :)


Dear Dina,

The name of a C/C++ function is not a simple identifier, but a constant pointer which stores the starting address of the executable code of the function (first machine code instruction). When type checking are performed by compilers, there is not considered a generic type of pointer to the function, but a particular pointer to a function which returns a certain type and has a certain list of arguments (of certain types, placed in a defined order).
 int (*fPtr)(int)  is a pointer to a function which returns an integer and requires a single parameter, which is also an integer. A definitely different data type would be  void (*pFun)(char*, int, bool)  which would be a function which does not return any value and requires three parameters: first is a pointer to a character (and can be used for an array of character, actually a string in C/C++), the second an integer, and the third is a boolean.
The pointer to a function is used when the actual processing needed on a certain moment is known just when the program is running (on run-time) rather than on compile-time (depending on user input, contents of a data file, previous computations, etc). For the fPtr as defined in your code, there can be employed more functions like
 int funAdd (int a) { return (3 + a) ; }
 int funMultiply (int a) { return (5 * a) ; }
 int funFormula (int a) { return (a * a + a + 4) ; }
The assignment of the pointer to such a function is a simple statement like
 fPtr = funAdd ;
 fPtr = funMultiply ;
 fPtr = funFormula ;
 (and all these functions should be employed at least once).
It is a system of indirect identification of the functions, and the most conventional call statement would be :
 fPtr(iOurData) ;  The value stored by fPtr is the entry point of the specified function's code, which is to be executed after receiving the value of the parameter.
The (*fPtr) (iOurData) ; is inconvenient, but has the same effect of calling a function. One could expect a retrieval of the value of the pointed-to variable (since a dereferencing is suggested), which is in this case the microprocessor operation code of the first instruction. However, compilers are build to start the execution of the encountered machine code rather than delivering such an machine operation code for storage in variables.
You should attempt a small demonstrative application to practice the indirect identification of functions, relying on my hints or something similar. Such demonstrative applications are the best method to confirm the assimilation of a new programming technique.

Good luck !

Experts Exchange Solution brought to you by

Your issues matter to us.

Facing a tech roadblock? Get the help and guidance you need from experienced professionals who care. Ask your question anytime, anywhere, with no hassle.

Start your 7-day free trial
No comment has been added lately, so it's time to clean up this TA.
I will leave the following recommendation for this question in the Cleanup topic area:

Split: amarzee {http:#9778046} & mrwad99 {http:#9779011} & MirkoLMV {http:#9801069}

Please leave any comments here within the next seven days.

EE Cleanup Volunteer
amarzee's comment was much the same as mine.  mrwad99's comment was true, but not relevant to the question, which did not mention pointers to member functions.  MirkoLMV's comment is mostly correct and probably helpful.  I suggest splitting points among me, amarzee, and MirkoLMV.

>> but not relevant to the question

Yeah fair comment efn; totally agree.

Split as suggested by efn :)
I am glad that I was of a help.
It's more than this solution.Get answers and train to solve all your tech problems - anytime, anywhere.Try it for free Edge Out The Competitionfor your dream job with proven skills and certifications.Get started today Stand Outas the employee with proven skills.Start learning today for free Move Your Career Forwardwith certification training in the latest technologies.Start your trial today

From novice to tech pro — start learning today.