Question

The goal is to have the member variable _AddValue point to the CreateFirstValue function upon class initialization and after the first invocation of AddValue, all future calls to it will invoke CreateAnotherValue.

Previously, I just had a single AddValue function with a conditional check to determine which function to call. However, I feel like that implementation is flawed because that if check will occur every time and it seems like a function pointer would be beneficial here.

An example:

class Foo
{
 private:
  int _value;
  void (*_AddValue)(int value); // Pointer to function member variable

  void CreateFirstValue(int value)
  {
    _value = value;
    _AddValue = &CreateAnotherValue;
  }

  void CreateAnotherValue(int value)
  {
    // This function will create values differently.
    _value = ...;
  }

 public:
  // Constructor
  Foo()
   : _value(0), _AddValue(CreateFirstValue)
  {
  }

  AddValue(int value) // This function is called by the user.
  {
    _AddValue(value);
  }
};

The code above is not the actual code, just an example of what I’m trying to accomplish.

right now I’m getting an error: argument of type void (BTree::)(int) does not match void (*)(int)

Answer 1

&CreateAnotherValue

This syntax is not valid. To create a pointer-to-member, you have to name the class, even from inside other members. Try

&Foo::CreateAnotherValue

In this case you are talking the address of a qualified non-static member function, which is allowed and prevents the error about address of unqualified member function.

Of course, you then need an appropriately typed variable to store the pointer-to-member in, see Bo’s answer for the correct declaration. When it comes time to call it, you will need to use the pointer-to-member-dereference operator (either .* or ->*), so say

(this->*_AddValue)(whatever);

The same rule applies to data, if you say &Foo::_value, you get a pointer-to-member of type int Foo::*. But in the data case, the unqualified name is also accepted, but with very different behavior. &_value gives a normal pointer, type int*, which is the address of the specific _value member variable inside the this instance.