Previously, we've seen how function pointers, and first-class functions in general, give us a lot of flexibility in designing our programs.

In the following example, our Party class has a for_each() method which accepts a function argument. It then invokes that function for every Player in the Party:

1#include <iostream>
2
3class Player {/*...*/};
8
9class Party {
10 public:
11  void for_each(auto Func) {  
12    Func(PlayerOne);          
13    Func(PlayerTwo);          
14    Func(PlayerThree);        
15  }                           
16
17 private:
18  Player PlayerOne{"Roderick"};
19  Player PlayerTwo{"Anna"};
20  Player PlayerThree{"Steve"};
21};

This allows the external code to execute an action for each Player. This design gives us a useful separation: the Party class implements and controls the iteration process, whilst external code can specify the behavior they want to happen on each iteration.

Below, our program uses a function pointer to provide behavior defined within the Log() function:

1#include <iostream>
2
3class Player {/*...*/};
8
9class Party {/*...*/};
23
24void LogName(Player& P) {       
25  std::cout << P.Name << '\n';  
26}  
27
28int main() {
29  Party MyParty;
30  MyParty.for_each(LogName);  
31}

1Roderick
2Anna
3Steve

In this lesson, we'll expand our techniques to include member function pointers - that is, pointers to functions that are part of a class or struct:

1#include <iostream>
2
3class Player {
4 public:
5  void LogName() {
6    std::cout << Name << '\n';
7  }
8  
9  std::string Name;
10};
11
12class Party {/*...*/};
26
27int main() {
28  Party MyParty;
29  
30  // We want to use the `Player::LogName()` function
31  MyParty.for_each(/* ??? */);
32}

This is more difficult than we might expect, so let's break down all the complexities.

Static and Non-Static Members

Most of this lesson deals specifically with non-static members - that is, members that are invoked within the context of some object that is a member of that class.

1#include <iostream>
2
3class Character {
4 public:
5  int GetHealth() { return Health; }
6  int Health;
7};
8
9int main() {
10  Character P1{50};
11  Character P2{100};
12
13  // Calling GetHealth() in the context of P1
14  std::cout << P1.GetHealth() << '\n';
15
16  // Calling GetHealth() in the context of P2
17  std::cout << P2.GetHealth();
18}

150
2100

Within the body of a class function, that object is available through the this pointer, and any other class functions or variables that the function directly references will also be invoked in that context:

1class Character {
2public:
3  int GetHealth() {
4    // Equivalent to this->Health
5    return Health;
6  }
7  
8  bool isAlive() {
9    // Equivalent to this->GetHealth()
10    return GetHealth() <= 0;
11  }
12  
13  int Health;
14};

Most members work this way so when we define class members, they are non-static by default. However, C++ also allows us to define static members:

1#include <iostream>
2
3class Character {
4 public:
5  // Static member function
6  static float GetArmor() { return Armor; }
7
8  // Static data member declaration
9  static float Armor;
10
11  // Non-static data member
12  int Health{100};
13};
14
15// Static data member definition
16float Character::Armor = 0.2;

Each object of a class get its own copy of non-static members which can be updated independently, but the value of non-static members is shared shared between all members of the class. That is, they point to the exact same memory location:

1#include <iostream>
2
3class Character {/*...*/};
18
19int main() {
20  Character A;
21  Character B;
22
23  if (&A.Armor == &B.Armor) {
24    std::cout << "Same Memory Address\n";
25  }
26
27  if (&A.Health != &B.Health) {
28    std::cout << "Different Memory Address\n";
29  }
30
31  // Updating a static member updates it for
32  // all instances of the class
33  A.Armor = 0.5;
34  std::cout << B.Armor;
35}

1Same Memory Address
2Different Memory Address
30.5

Because of this, static members do not need to be accessed in the context of any specific member. As a result, they will not have access to the this pointer, and cannot directly use any other class members unless those members are also static.

Conceptually, static members are very similar to free functions and variables, with the class acting like a namespace:

1#include <iostream>
2
3class Character {/*...*/};
18
19int main() {
20  // Creating an object is unnecessary - we can
21  // directly access static members from the
22  // class using the :: operator
23  std::cout << Character::Armor << '\n';
24  std::cout << Character::GetArmor();
25}

10.2
20.2

Pointers to static members work in the exact same way and have the same type as pointers to free functions and variables:

1struct ExampleType{
2  static int Add(int x, int y) {
3    return x + y;
4  }
5  
6  static int Value;
7};
8
9int ExampleType::Value = 42;
10
11int Add(int x, int y) {
12  return x + y;
13}
14
15int main() {
16  int LocalVariable{50};
17
18  int* PointerA{&LocalVariable};
19  int* PointerB{&ExampleType::Value};
20
21  int (*PointerC)(int x, int y){
22    Add
23  };
24
25  int (*PointerD)(int x, int y){
26    &ExampleType::Add
27  };
28}

We cover static members in more detail in a dedicated lesson later in the course.

Pointers to Member Functions

Pointers to non-static member functions are a little more complex, as these functions must be called in the context of some instance of that class. Accordingly, their types are more complex, as they include the name of that class:

1#include <string>
2
3class Character {/*...*/};
16
17int main() {
18  // Returns a std::string and accepts no args
19  std::string (Character::*Getter)(){
20    &Character::GetName};
21
22  // Returns void and accepts std::string arg
23  void (Character::*Setter)(const std::string&){
24    &Character::SetName};
25}

We can introduce type aliases to make this syntax friendlier if desired:

1#include <string>
2
3class Character {/*...*/};
16
17int main() {
18  using GetNamePtrType =
19    std::string (Character::*)();
20
21  using SetNamePtrType =
22    void (Character::*)(const std::string&);
23
24  GetNamePtrType Getter{&Character::GetName};
25  SetNamePtrType Setter{&Character::SetName};
26}

The standard library includes a variety of helpers to make working with pointers to member functions easier. We'll cover these later in this lesson.

Pointer-to-Member Operators

Invoking a member function through a pointer to it is more complex than invocing free function pointers, functors, or lambdas. That is because, if the function we're pointing at isn't static, it needs to be invoked in the context of some member of that class.

As we've seen, when we know what we want to invoke, we provide the context object using the . or -> operator:

1#include <string>
2
3class Character {/*...*/};
16
17int main() {
18  // Call GetName() in the context of PlayerOne
19  Character PlayerOne;
20  PlayerOne.GetName();
21
22  // Call GetName() in the context of PlayerTwo
23  Character PlayerTwo;
24  PlayerTwo.GetName();
25
26  // Call SetName() in the context of PlayerTwo
27  Character* Ptr{&PlayerTwo};
28  Ptr->SetName("Anna");
29}

When the thing we want to invoke is defined by a pointer to a member, C++ includes two operators, commonly called the pointer-to-member operators, to let us provide that context object.

The `.*` Operator

With the .* operator, we provide the context object as the left operand, and the member function pointer as the right. For example, if we have a member function pointer called Pointer, and our context object is called Object, our syntax would be Object.*Pointer.

We then invoke what is returned by this operation using the () operator as normal. Note however that the () operator has higher precedence than the .* operator. To ensure the .* operation happens first, we need to introduce an extra set of parenthesis, giving (Object.*Pointer)().

Here's an example:

1#include <iostream>
2
3class Character {/*...*/};
16
17int main() {
18  using GetNamePtrType =
19    std::string (Character::*)();
20
21  GetNamePtrType GetName{&Character::GetName};
22  Character PlayerOne{"Anna"};
23
24  std::cout << (PlayerOne.*GetName)();
25}

1Anna

If our method requires arguments, we pass them within the () operator as normal:

1#include <iostream>
2
3class Character {/*...*/};
16
17int main() {
18  using SetNamePtrType =
19    void (Character::*)(const std::string&);
20
21  SetNamePtrType SetName{&Character::SetName};
22  Character PlayerOne{"Anna"};
23
24  (PlayerOne.*SetName)("Roderick");
25
26  std::cout << PlayerOne.GetName();
27}

1Roderick

The `->*` Operator

The .* operator accepts a context object as the left operand, but what if we only have a pointer to the context object? We could dereference it in the normal way, using the * operator:

1#include <iostream>
2
3class Character {/*...*/};
16
17int main() {
18  using GetNamePtrType =
19    std::string (Character::*)();
20  using SetNamePtrType =
21    void (Character::*)(const std::string&);
22
23  GetNamePtrType GetName{&Character::GetName};
24  SetNamePtrType SetName{&Character::SetName};
25  Character PlayerOne{"Anna"};
26  Character* PlayerPtr{&PlayerOne};
27
28  std::cout << (*PlayerPtr.*GetName)() << '\n';
29  (*PlayerPtr.*SetName)("Roderick");
30  std::cout << (*PlayerPtr.*GetName)();
31}

1Anna
2Roderick

Alternatively, C++ provides the ->* operator, allowing us to combine the * and .* operations into a single step. We provide the pointer to the context object as the left operand and the member function pointer as the right:

1#include <iostream>
2
3class Character {/*...*/};
16
17int main() {
18  using GetNamePtrType =
19    std::string (Character::*)();
20  using SetNamePtrType =
21    void (Character::*)(const std::string&);
22
23  GetNamePtrType GetName{&Character::GetName};
24  SetNamePtrType SetName{&Character::SetName};
25  Character PlayerOne{"Anna"};
26  Character* PlayerPtr{&PlayerOne};
27
28  std::cout << (PlayerPtr->*GetName)() << '\n';
29  (PlayerPtr->*SetName)("Roderick");
30  std::cout << (PlayerPtr->*GetName)();
31}

1Anna
2Roderick

The `std::invoke()` Function

The std::invoke() was added to the standard library in C++17, giving us an alternative way to call functions:

1int Add(int x, int y) {
2  return x + y;
3}
4
5int main() {
6  Add(1, 2);
7  
8  // Equivalently:
9  std::invoke(Add, 1, 2);
10}

One of the benefits of std::invoke() is that it provides a standard way to execute callables, regardless of the callable type. We've seen how invoking a lambda, for example, uses the basic () syntax, whilst a member function requires the ->* or .* operator.

This is a problem as, when we're writing a function that receives a callable as an argument, we typically want to support any type of callable:

1#include <iostream>
2
3class Player {
4public:
5  std::string GetName() { return Name; }
6  std::string Name;
7};
8
9void Log(auto Getter, Player& Object) {
10  // Incompatible with member function pointers
11  std::cout << Getter(Object) << '\n';
12
13  // Incompatible with functors, lambdas, etc
14  std::cout << (Object.*Getter)() << '\n';
15}
16
17int main() {
18  Player PlayerOne{"Anna"};
19  Log(&Player::GetName, PlayerOne);
20  Log(
21    [](Player& P){ return P.Name; },
22    PlayerOne
23  );
24}

1error: term does not evaluate to a function taking 1 argument
2error: '.*': not valid as right operand

We could work around that using compile-time techniques like assessing type traits, but std::invoke() takes care of that for us.

To invoke a non-static member function using std::invoke, we supply the context object as the second argument. std::invoke can receive this by reference or pointer, including smart pointer:

1#include <iostream>
2
3class Player {
4 public:
5  std::string GetName() { return Name; }
6  std::string Name;
7};
8
9int main() {
10  Player PlayerOne{"Anna"};
11  auto Ptr{&Player::GetName};
12
13  std::cout << std::invoke(Ptr, PlayerOne) << '\n';
14  std::cout << std::invoke(Ptr, &PlayerOne);
15}

1Anna
2Anna

If our member function requires arguments, we provide them after the context object:

1#include <iostream>
2
3class Player {
4 public:
5  void SetName(std::string NewName, bool Log) {
6    Name = NewName;
7    if (Log) {
8      std::cout << "Name is now " << Name;
9    }
10  }
11
12  std::string Name;
13};
14
15int main() {
16  Player PlayerOne;
17  auto Ptr{&Player::SetName};
18
19  std::invoke(Ptr, PlayerOne, "Anna", true);
20}

1Name is now Anna

In the following example, we've written Log() using std::invoke(), meaning it is now compatible with both lambdas and member function pointers:

1#include <iostream>
2
3class Player {
4public:
5  std::string GetName() { return Name; }
6
7  std::string Name;
8};
9
10void Log(auto Getter, Player& Object) {
11  std::cout << std::invoke(Getter, Object) << '\n';
12}
13
14int main() {
15  Player PlayerOne{"Anna"};
16  Log(&Player::GetName, PlayerOne);
17  Log(
18    [](Player& P){ return P.Name; },
19    PlayerOne
20  );
21}

1Anna
2Anna

`std::is_member_pointer`

Before C++17, or if we need to determine whether a type is a member pointer anyway, the standard library includes the std::is_member_pointer type trait to help us:

1#include <iostream>
2#include <type_traits>
3
4class Player {/*...*/};
10
11template <typename T>
12void Log(T Getter, Player& Object) {
13  if constexpr (std::is_member_pointer_v<T>) {
14    std::cout << "Member pointer: "
15      << (Object.*Getter)() << '\n';
16  } else {
17    std::cout << "Not a member pointer: "
18      << Getter(Object) << '\n';
19  }
20}
21
22int main() {
23  Player PlayerOne{"Anna"};
24
25  Log(&Player::GetName, PlayerOne);
26  Log([](Player& P){
27    return P.Name;
28  }, PlayerOne);
29}

1Member pointer: Anna
2Not a member pointer: Anna

Type Traits: Compile-Time Type Analysis

Learn how to use type traits to perform compile-time type analysis, enable conditional compilation, and enforce type requirements in templates.

View Related Lesson

The `std::mem_fn()` Function

The standard library's <functional> header includes std::mem_fn(). This function accepts a member function pointer and returns a lightweight wrapper. This wrapper allows us to use that member pointer like a regular function, using the basic () operator.

When invoking the functor returned by std::mem_fn(), we provide the context object as the first argument:

1#include <functional>
2#include <iostream>
3
4class Player {
5public:
6  std::string GetName() { return Name; }
7
8  std::string Name;
9};
10
11int main() {
12  Player PlayerOne{"Anna"};
13
14  auto GetName{std::mem_fn(&Player::GetName)};
15
16  std::cout << GetName(PlayerOne);
17}

1Anna

If our member function requires additional arguments, we provide them after the context object:

1#include <functional>
2#include <iostream>
3
4class Player {
5public:
6  std::string GetName() { return Name; }
7 void SetName(const std::string& NewName) {
8    Name = NewName;
9  }
10
11  std::string Name;
12};
13
14int main() {
15  Player PlayerOne;
16
17  auto SetName{std::mem_fn(&Player::SetName)};
18  SetName(PlayerOne, "Anna");
19
20  std::cout << PlayerOne.GetName();
21}

This utility is primarily useful if we need to provide a callable to an API that doesn't directly support member function pointers, using a technique like std::invoke, and we can't update it.

We could handle this incompatibility by introducing an intermediate lambda, for example, but std::mem_fn() takes care of that for us:

1#include <functional>
2#include <iostream>
3
4class Player {
5 public:
6  std::string GetName() { return Name; }
7
8  std::string Name;
9};
10
11void Log(auto Getter, Player& Object) {
12  // Not compatible with member pointers
13  std::cout << Getter(Object) << '\n';  
14}
15
16int main() {
17  Player PlayerOne{"Anna"};
18
19  // Intermediate lambda for compatibility:
20  Log([](const Player& P){
21    return P.Name;
22  }, PlayerOne);
23
24  // Alternative using std::mem_fn():
25  Log(std::mem_fn(&Player::GetName), PlayerOne);
26}

1Anna
2Anna

Preview: Partial Application

In real-world applications, it's quite rare for us to provide both a member function pointer and a context object to pass as the first argument.

Most real-world APIs will simply require a function they can call without needing to forward any consumer-provided arguments. To solve this, functional programming includes the notion of partial application, which allows us to provide only some of the required arguments.

This is sometimes referred to as binding, and the binding process returns a new callable object. This callable can then be invoked by passing only the remaining arguments, or no arguments at all if we bound everything that was required.

Below, we use std::bind() to provide the context object to our Player::GetName() function. The object returned by std::bind() is then passed to the Log() function.

Player::GetName() has no further parameters, so Log() can invoke the bound object without needing to provide any arguments:

1#include <functional> // For std::bind 
2#include <iostream>
3
4class Player {
5 public:
6  std::string GetName() { return Name; }
7  std::string Name;
8};
9
10void Log(auto Getter) {
11  std::cout << Getter();  
12}
13
14int main() {
15  Player PlayerOne{"Anna"};
16  Log(std::bind(&Player::GetName, &PlayerOne));
17}

1Anna

We cover function binding in detail in the next lesson.

Access Restrictions

Creating a pointer to a member function is controlled by member access specifiers like private and protected in the way we might expect.

In the following example, PrivateMethod is private, so our main function cannot create a pointer to it:

1#include <iostream>
2
3class Player {
4  void PrivateMethod() {
5    std::cout << "Invoking Private Method";
6  }
7};
8
9int main() {
10  auto Ptr{&Player::PrivateMethod};
11}

1error: 'Player::PrivateMethod': cannot access private member declared in class 'Player'

However, member function pointers provide some additional flexibility here. We can provide access to private or protected functions through less restrictive methods:

1class Player {
2 public:
3  static auto GetPtr() {
4    return &Player::PrivateMethod;
5  }
6
7 private:
8  void PrivateMethod() {
9    std::cout << "Invoking Private Method";
10  }
11};

Once we have a pointer to a private or protected function, we can pass it around and invoke the function without any restrictions:

1#include <iostream>
2
3class Player {
4 public:
5  static auto GetPtr() {
6    return &Player::PrivateMethod;
7  }
8
9 private:
10  void PrivateMethod() {
11    std::cout << "Invoking Private Method";
12  }
13};
14
15int main() {
16  auto Ptr{Player::GetPtr()};
17
18  Player PlayerOne;
19  std::invoke(Ptr, &PlayerOne);
20}

1Invoking Private Method

Pointers to `virtual` Methods

Member function pointers interact with virtual functions in the way we might expect. Below, our Combat function accepts a reference to a Character, and then calls the Attack() method.

We pass a Dragon to this function but, because Character::Attack() is not virtual, our invocation is bound at compile time. Because Attacker is a Character& within the Combat() function, Character::Attack() will be used:

1#include <iostream>
2
3class Character {
4 public:
5  void Attack() {
6    std::cout << "Using Character Attack";
7  }
8};
9
10class Dragon : public Character {
11 public:
12  void Attack() {
13    std::cout << "Using Dragon Attack";
14  }
15};
16
17void Combat(auto Function, Character& Attacker) {
18  std::invoke(Function, Attacker);
19}
20
21int main() {
22  Dragon Monster;
23  Combat(&Character::Attack, Monster);
24}

1Using Character Attack

If we update Character::Attack() to be virtual (and optionally update Dragon::Attack() to be an override), our invocation of Attacker.Attack() is bound at run time.

Now, our Combat(), function does additional work to determine the specific subtype the Attacker has. It is a Dragon in this example, so Dragon::Attack() will be used:

1#include <iostream>
2
3class Character {
4 public:
5  virtual void Attack() {
6    std::cout << "Using Character Attack";
7  }
8};
9
10class Dragon : public Character {
11 public:
12  void Attack() override {
13    std::cout << "Using Dragon Attack";
14  }
15};
16
17// Unchanged
18void Combat(auto Function, Character& Attacker) {
19  std::invoke(Function, Attacker);
20}
21
22// Unchanged
23int main() {
24  Dragon Monster;
25  Combat(&Character::Attack, Monster);
26}

1Using Dragon Attack

Using `const` with Member Function Pointers

As with most other types of pointer, the const keyword can be used in two ways:

The pointer is const
The function the pointer is pointing at is const

This creates four possible combinations. The first we've already seen - in previous examples, neither the pointer nor the function being pointed at was const. Let's see examples of the three other possibilities.

`const` Pointer

A const variable that stores a member function pointer works in the same way as any other const variable. Once the variable is initialized, we can't update it to point to a different function:

1#include <iostream>
2
3class Character {
4 public:
5  std::string GetName() const {
6    return Name;
7  }
8
9  void SetName(const std::string& NewName) {
10    Name = NewName;
11  }
12
13  std::string Name;
14};
15
16int main() {
17  using SetNamePtrType =
18    void (Character::*)(const std::string&);
19
20  Character PlayerOne;
21
22  // Creating a const pointer
23  const SetNamePtrType SetName{
24    &Character::SetName};
25
26  // This is fine
27  (PlayerOne.*SetName)("Anna");  
28
29  // This is not
30  SetName = nullptr;  
31}

1error: 'SetName': you cannot assign to a variable that is const

Pointer to `const`

When a member function is const, that const-ness will also be reflected in the type of any variable that stores a pointer to it:

1#include <iostream>
2
3class Character {
4 public:
5  std::string GetName() const {
6    return Name;
7  }
8
9  std::string Name;
10};
11
12int main() {
13  using GetNamePtrType =
14    std::string (Character::*)() const;
15
16  GetNamePtrType Func{&Character::GetName};
17}

If an instance of our class is const, any member function pointer we're invoking on it must also be a pointer-to-const:

1#include <iostream>
2
3class Character {
4 public:
5  std::string GetName() const {
6    return Name;
7  }
8
9  void SetName(const std::string& NewName) {
10    Name = NewName;
11  }
12
13  std::string Name;
14};
15
16int main() {
17  using GetNamePtrType =
18    std::string (Character::*)() const;
19
20  using SetNamePtrType =
21    void (Character::*)(const std::string&);
22
23  GetNamePtrType GetName{&Character::GetName};
24  SetNamePtrType SetName{&Character::SetName};
25
26  // Creating a const Character
27  const Character PlayerOne; 
28
29  // GetName is a pointer to const
30  // so this is fine
31  (PlayerOne.*GetName)();
32
33  // SetName is a pointer to non-const
34  // so this will generate a compilation error
35  (PlayerOne.*SetName)("Roderick");
36
37  // SetName itself is not const
38  // so this is fine:
39  SetName = nullptr;
40}

1error: 'argument': cannot convert from 'const Character' to 'Character &'

`const` Pointer to `const`

Finally, we can use const in both contexts, giving us a const pointer to const:

1#include <iostream>
2
3class Character {
4 public:
5  std::string GetName() const {
6    return Name;
7  }
8
9  void SetName(const std::string& NewName) {
10    Name = NewName;
11  }
12
13  std::string Name;
14};
15
16int main() {
17  using GetNamePtrType =
18    std::string (Character::*)() const;
19
20
21  const GetNamePtrType GetName{&Character::GetName};
22
23  SetName = nullptr;
24}

1error: 'GetName': you cannot assign to a variable that is const

Pointers to Data Members

We're not restricted to creating pointers to member functions - we point to data members in the same way:

1#include <iostream>
2
3class Player {
4 public:
5  int GetScore() {
6    return Score;
7  }
8
9  int Score;
10};
11
12int main() {
13  Player John{50};
14
15  // Pointer to Function Member
16  int (Player::*FunctionPtr)(){&Player::GetScore};
17  std::cout << "Function Member: "
18    <<(John.*FunctionPtr)();
19
20  // Pointer to Data Member
21  int Player::*DataPtr{&Player::Score};
22  std::cout << "\nData Member using .* "
23    << John.*DataPtr;
24
25  Player* JohnPtr{&John};
26  std::cout << "\nData Member using ->* "
27    << JohnPtr->*DataPtr;
28
29  // Updating Data Member through Pointer:
30  std::cout << "\nUpdating Data Member using .* "
31    << (John.*DataPtr += 50);
32
33  std::cout << "\nUpdating Data Member using ->* "
34    << (JohnPtr->*DataPtr += 50);
35}

1Function Member: 50
2Data Member using .* 50
3Data Member using ->* 50
4Updating Data Member using .* 100
5Updating Data Member using ->* 150

An additional benefit of the std::invoke() helper is that the first argument can be a pointer to a data member, giving us even more flexibility:

1#include <iostream>
2
3class Player {
4 public:
5  std::string Name;
6};
7
8void Log(auto Getter, Player& Object) {
9  std::cout << std::invoke(Getter, Object) << '\n';
10}
11
12int main() {
13  Player PlayerOne{"Anna"};
14
15  // We can use a lambda:
16  Log([](Player& P){
17    return P.Name;
18  }, PlayerOne);
19
20  // Or a simple pointer-to-member:
21  Log(&Player::Name, PlayerOne);
22}

1Anna
2Anna

This is true of many other standard library utilities, including std::mem_fn() and binding functions such as std::bind_front():

1#include <iostream>
2#include <functional>
3
4class Player {
5 public:
6  int Score;
7};
8
9int main() {
10  Player John(50);
11  int Player::*Ptr{&Player::Score};
12
13  std::cout << "Using std::invoke: "
14    << std::invoke(Ptr, &John) << '\n';
15
16  auto GetPlayerScore{std::mem_fn(Ptr)};
17  std::cout << "Using std::mem_fn: "
18    << GetPlayerScore(&John) << '\n';
19
20  auto GetJohnScore{std::bind_front(Ptr, &John)};
21  std::cout << "Using std::bind_front: "
22    << GetJohnScore();
23}

1Using std::invoke: 50
2Using std::mem_fn: 50
3Using std::bind_front: 50

Pointers to Static Data Members

Pointers to static data members are much simpler, behaving exactly like pointers to any other variable:

1#include <iostream>
2
3class Player {
4 public:
5  static int Health;
6};
7
8int Player::Health{100};
9
10int main() {
11  int* PlayerHealth{&Player::Health};
12  std::cout << *PlayerHealth;
13}

Summary

In this lesson, we've expanded our knowledge of function pointers to include member function pointers. Here are the key takeaways:

Static member function pointers behave similarly to free function pointers and are useful for global game functions.
Non-static member function pointers require an object instance to be called and represent object-specific behaviors.
The .* and ->* operators are used to invoke member functions through pointers.
std::invoke provides a modern, uniform way to call any callable object, including member function pointers.
std::mem_fn() wraps member function pointers for use in generic code and algorithms.
std::function can simplify the typing of complex member function pointers and provide a uniform interface for different types of callables.
Member function pointers can have const qualifiers, affecting how they can be used.

Pointers to Members

Static and Non-Static Members

Pointers to Member Functions

Pointer-to-Member Operators

The `.*` Operator

The `->*` Operator

The `std::invoke()` Function

The `std::mem_fn()` Function

Access Restrictions

Pointers to `virtual` Methods

Using `const` with Member Function Pointers

`const` Pointer

Pointer to `const`

`const` Pointer to `const`

Pointers to Data Members

Pointers to Static Data Members

Summary

Function Binding and Partial Application

Professional C++

Questions & Answers

Pointers to Members

Static and Non-Static Members

Pointers to Member Functions

Pointer-to-Member Operators

The .* Operator

The ->* Operator

The std::invoke() Function

The std::mem_fn() Function

Access Restrictions

Pointers to virtual Methods

Using const with Member Function Pointers

const Pointer

Pointer to const

const Pointer to const

Pointers to Data Members

Pointers to Static Data Members

Summary

Function Binding and Partial Application

Questions & Answers

The `.*` Operator

The `->*` Operator

The `std::invoke()` Function

The `std::mem_fn()` Function

Pointers to `virtual` Methods

Using `const` with Member Function Pointers

`const` Pointer

Pointer to `const`

`const` Pointer to `const`