C++ Function call via an object with public member pointer to function, without using dereference operator

Question

Alright, I think the title is sufficiently descriptive (yet confusing, sorry).

I'm reading this library: Timer1.

In the header file there is a public member pointer to a function as follows:

class TimerOne
{
  public:
  void (*isrCallback)();  // C-style ptr to `void(void)` function
};

There exists an instantiated object of the TimerOne class, called "Timer1".

Timer1 calls the function as follows:

Timer1.isrCallback();

How is this correct? I am familiar with calling functions via function pointers by using the dereference operator.

Ex:

(*myFunc)();

So I would have expected the above call via the object to be something more like:

(*Timer1.isrCallback)();

So, what are the acceptable options for calling functions via function pointers, as both stand-alone function pointers and members of an object?

See also:

1. [very useful!] Typedef function pointer?

Summary of the answer:

These are all valid and fine ways to call a function pointer:

myFuncPtr();
(*myFuncPtr)();
(**myFuncPtr)();
(***myFuncPtr)();
// etc.
(**********************************f)(); // also valid

Answer 1

Things you can do with a function pointer.

1: The first is calling the function via explicit dereference:

int myfunc(int n)
{
}

int (*myfptr)(int) = myfunc; 

(*myfptr)(nValue); // call function myfunc(nValue) through myfptr.

2: The second way is via implicit dereference:

int myfunc(int n)
{
}

int (*myfptr)(int) = myfunc;

myfptr(nValue); // call function myfunc(nValue) through myfptr.

As you can see, the implicit dereference method looks just like a normal function call -- which is what you’d expect, since function are simply implicitly convertible to function pointers!!

In your code:

void foo()
{
    cout << "hi" << endl;
}

class TimerOne
{
public:

    void(*isrCallback)();
};


int main()
{

    TimerOne Timer1;
    Timer1.isrCallback = &foo;   //Assigning the address
    //Timer1.isrCallback = foo;   //We could use this statement as well, it simply proves function are simply implicitly convertible to function pointers. Just like arrays decay to pointer.
    Timer1.isrCallback();         //Implicit dereference
    (*Timer1.isrCallback)();      //Explicit dereference
        return 0;
}

Answer 2

You don't have to dereference a function pointer to call it. According to the standard ([expr.call]/1),

The postfix expression shall have function type or pointer to function type.

So (*myFunc)() is valid, and so is myFunc(). In fact, (**myFunc)() is valid too, and you can dereference as many times as you want (can you figure out why?)

Answer 3

You asked:

Timer1 calls the function as follows:

Timer1.isrCallback();

How is this correct?

The type of Timer1.isrCallback is void (*)(). It is a pointer to a function. That's why you can use that syntax.

It is similar to using:

void foo()
{
}

void test_foo()
{
   void (*fptr)() = foo;
   fptr();
}

You can also use:

void test_foo()
{
   void (*fptr)() = foo;
   (*fptr)();
}

but the first form is equally valid.

Update, in response to comment by OP

Given the posted definition of the class you would use:

(*Timer1.isrCallback)(); 

To use

(Timer1.*isrCallback)(); 

isrCallback has to be defined as a non-member variable of whose type is a pointer to a member variable of TimerOne.

void (TimerOne::*isrCallback)();

Example:

#include <iostream>

class TimerOne
{
  public:
  void foo()
  {
     std::cout << "In TimerOne::foo();\n";
  }
};

int main()
{
   TimerOne Timer1;
   void (TimerOne::*isrCallback)() = &TimerOne::foo;
   (Timer1.*isrCallback)();
}

Output:

In TimerOne::foo();

(Test this code)

---

If you want to define isrCallbak as a member variable of TimerOne, you'll need to use:

#include <iostream>

class TimerOne
{
  public:
  void (TimerOne::*isrCallback)();
  void foo()
  {
     std::cout << "In TimerOne::foo();\n";
  }
};

int main()
{
   TimerOne Timer1;
   Timer1.isrCallback = &TimerOne::foo;

   // A little complicated syntax.
   (Timer1.*(Timer1.isrCallback))();
}

Output:

In TimerOne::foo();

(Test this code)