Member Function Pointers and Binding

Explore advanced techniques for working with class member functions

This lesson is part of the course:

Game Dev with SDL2

Learn C++ and SDL development by creating hands on, practical projects inspired by classic retro games

Free, Unlimited Access

Abstract art representing computer programming

Ryan McCombe

Posted 2 months ago

Previously, we’ve seen how we can create pointers to free functions:

1#include <functional>
2
3void FreeFunction() {/*...*/}
4
5int main() {
6  std::function FunctionPtr{FreeFunction};
7}

In large projects, it’s more common that we’ll be working with member functions - that is, functions that are defined as part of a class or struct:

1class SomeClass {
2  void MemberFunction() {/*...*/}
3};

In this lesson, we’ll learn how to work with pointers to these types of functions, and manage the additional complexity that is involved.

Static Member Functions

Creating a pointer to a static member function is similar to creating a pointer to a free function. The main difference is that we additionally need to specify what class the function belongs to, using the scope resolution operator ::.

For example, a static function called Greet() in the Greeter class can be identified using Greeter::Greet. We can create a pointer to such a function in the usual way:

1#include <iostream>
2#include <functional>
3
4class Greeter {
5public:
6  static void Greet() {
7    std::cout << "Hello World";
8  }
9};
10
11int main() {
12  std::function FunctionPtr{Greeter::Greet};
13  FunctionPtr();
14}

1Hello World

Non-Static Member Functions

As we’ve seen, non-static member functions behave a little differently from regular functions, in that they are called in the context of some object.

Below, we call GetName() in the context of PlayerOne, meaning when the function uses an identifier like Name, it will be accessing the Name variable of the PlayerOne object:

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

We can create a pointer to a member function in the same way. Note, when creating a pointer to a non-static member function, the & operator is required:

1auto NameGetter{&Player::GetName};

The key difference arises when we want to invoke a non-static member function, as we need to provide the context object. This is an instance of the Player class, such as PlayerOne in our previous example. The std::mem_fn() helper within <functional> can help us with this.

Passing our function pointer to this helper returns a new callable object, which allows us to invoke our function by passing the context object as the first argument. The object returned by std::mem_fn() is flexible, allowing us to provide this argument by reference, pointer, or smart pointer:

1#include <functional>
2#include <iostream>
3#include <string>
4
5class Player {
6 public:
7  std::string GetName() { return Name; }
8  std::string Name;
9};
10
11int main() {
12  Player PlayerOne{"Anna"};
13  auto NameGetter{std::mem_fn(&Player::GetName)};
14
15  // By Reference
16  std::cout << NameGetter(PlayerOne) << '\n';
17
18  // By Pointer
19  std::cout << NameGetter(&PlayerOne) << '\n';
20
21  // By Smart Pointer
22  auto Ptr{std::make_unique<Player>("John")};
23  std::cout << NameGetter(Ptr);
24}

1Anna
2Anna
3John

If the member function has additional parameters, we provide those arguments after the context object:

1#include <functional>
2#include <iostream>
3
4class Player {
5 public:
6  void TakeDamage(int Damage) {
7    Health -= Damage;
8  }
9  int Health;
10};
11
12int main() {
13  Player PlayerOne{100};
14  auto InflictDamage{std::mem_fn(
15    &Player::TakeDamage)};
16
17  InflictDamage(PlayerOne, 75);
18
19  std::cout << "Remaining Health: "
20  << PlayerOne.Health;
21}

1Remaining Health: 25

Typing Member Functions

A pointer to a static member function has the same type signature as a pointer to a free function:

1void FuncA() {}
2bool FuncB(int, float) {}
3
4class MyClass {
5 public:
6  static void FuncC() {}
7  static bool FuncD(int, float) {}
8};
9
10int main() {
11  // Free Functions
12  void (*PtrA)(){FuncA}
13  bool (*PtrB)(int, float){FuncB};
14
15  // Static Functions
16  void (*PtrC)(){MyClass::FuncC}
17  bool (*PtrD)(int, float){MyClass::FuncD};
18}

However, the type of a non-static member function is a little more complex, as it includes the identifier of the class the function is a member of:

1class MyClass {
2 public:
3  void NonStaticFunction() {}
4  bool FunctionWithParameters(int x, float y) {
5    return true;
6  }
7};
8
9int main() {
10  // Non-Static Function
11  void (MyClass::*PtrB)(){
12    MyClass::NonStaticFunction};
13
14  // Non-Static Function With Parameters
15  bool (MyClass::*PtrC)(int, float){
16    MyClass::FunctionWithParameters};
17}

In practice, however, we’d typically type and transfer functions using the std::function helper, as we introduced in the previous lesson.

When using std::function with a non-static member, we include an instance of that member’s class as the first parameter:

1#include <functional>
2
3class MyClass {/*...*/};
12
13int main() {
14  // Static Function
15  std::function<void()> PtrA{
16    MyClass::StaticFunction};
17
18  // Non-Static Function
19  std::function<void(MyClass&)>{
20    &MyClass::NonStaticFunction};
21
22  // Non-Static Function With Parameters
23  std::function<bool(MyClass&, int, float)> PtrC{
24    &MyClass::FunctionWithParameters};
25}

Binding and Partial Application

When passing a member function to some other object to use as a callback, it can be quite cumbersome and restrictive to require that function to also provide the context object.

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 Logger(auto GetString) {
12  std::cout << GetString(
13    Context  // How do I get this argument?
14  );
15}
16
17int main() {
18  Player PlayerOne{"Anna"};
19  Logger(std::mem_fn(&Player::GetName));
20}

To solve this, we can use partial application. "Applying" a function refers to providing all of the required arguments and invoking it. With pretty much every function invocation we’ve performed, we’ve been fully applying it. That is, we provided all the arguments and invoked them immediately:

1#include <iostream>
2
3int Add(int x, int y) {
4  return x + y;
5}
6
7int main() {
8  std::cout << Add(1, 2);
9}

But with partial application, we can divide the application of the function into different steps, performed at different times.

This relies on binding, which allows us to provide some (or all) of the function’s required arguments. This binding process returns a partially applied function which we can call later, and provide any remaining arguments if required.

In the following example, we have a function that accepts three arguments. We use std::bind_front() to provide the value of the first argument (1 in this case). This returns a partially applied function:

1#include <functional>
2
3int Add(int x, int y, int z) {
4  return x + y + z;
5}
6
7int main() {
8  auto Partial{std::bind_front(Add, 1)};
9}

We can then later call this function, providing the remaining arguments:

1#include <iostream>
2#include <functional>
3
4int Add(int x, int y, int z) {
5  return x + y + z;
6}
7
8int main() {
9  auto Partial{std::bind_front(Add, 1)};
10  std::cout << Partial(2, 3);
11}

We can bind multiple arguments:

1#include <iostream>
2#include <functional>
3
4int Add(int x, int y, int z) {
5  return x + y + z;
6}
7
8int main() {
9  auto Partial{std::bind_front(Add, 1, 2)};
10  std::cout << Partial(3);
11}

We can bind all arguments, leaving only the invocation for later:

1#include <iostream>
2#include <functional>
3
4int Add(int x, int y, int z) {
5  return x + y + z;
6}
7
8int main() {
9  auto Partial{std::bind_front(Add, 1, 2, 3)};
10  std::cout << Partial();
11}

We can reuse partially-applied functions:

1#include <iostream>
2#include <functional>
3
4int Add(int x, int y, int z) {
5  return x + y + z;
6}
7
8int main() {
9  auto Partial{std::bind_front(Add, 1, 2)};
10  std::cout << Partial(3) << ", " << Partial(4);
11}

16, 7

We can also split the partial application across as many steps as needed:

1#include <iostream>
2#include <functional>
3
4int Add(int x, int y, int z) {
5  return x + y + z;
6}
7
8int main() {
9  auto PartialA{std::bind_front(Add, 1)};
10  auto PartialB{std::bind_front(PartialA, 2)};
11  auto PartialC{std::bind_front(PartialB, 3)};
12  std::cout << PartialC();
13}

Binding Member Functions

Let’s solve the original problem by partially applying a member function using the context object. This absolves the caller from needing to provide it later.

When binding a member function, std::bind_front() includes the behavior of std::mem_fn(), allowing us to provide the context object as the first argument.

The bound function returned from std::bind_front() additionally allows us to provide this context object either by value or pointer.

If we pass our context object by value, std::bind_front() will create a copy of the object. When we later call our bound function, it will be called in the context of that copy.

Below, our Player was called "Anna" at the time we bound it. We later changed our name to "John", but because we passed PlayerOne by value to std::bind_front(), the copy within our bound function is still called "Anna":

1#include <functional>
2#include <iostream>
3
4class Player {/*...*/};
11
12void Logger(auto GetString) {/*...*/}
16
17int main() {
18  Player PlayerOne{"Anna"};
19
20  auto BoundFunction{std::bind_front(
21    &Player::GetName,
22    PlayerOne // Passing by value
23  )};
24
25  PlayerOne.Name = "John";
26
27  Logger(BoundFunction);
28}

1Anna

Alternatively, we can bind to a pointer. This approach avoids the performance cost of creating a copy of our object.

Moreover, when we later invoke our function, it will be called in the context of the original object, reflecting any changes we've made to it:

1#include <functional>
2#include <iostream>
3
4class Player {/*...*/};
11
12void Logger(auto GetString) {/*...*/}
16
17int main() {
18  Player PlayerOne{"Anna"};
19
20  auto BoundFunction{std::bind_front(
21    &Player::GetName,
22    &PlayerOne // Passing by pointer
23  )};
24
25  PlayerOne.Name = "John";
26
27  Logger(BoundFunction);
28}

1John

`std::bind()` and `std::placeholders`

The std::bind_front() function was added in C++20, so may not be available in all projects.

We can accomplish the same goals using std::bind() and std::placeholders. These utilities are slightly more complex, but give us more flexibility and are available in older language versions.

Our dedicated lesson on partial application covers this in detail:

Function Binding and Partial Application

This lesson covers function binding and partial application using std::bind(), std::bind_front(), std::bind_back() and std::placeholders.

Returning Member Functions

Like with any other function pointer, our functions can return pointers to member functions:

1#include <functional>
2#include <string>
3#include <iostream>
4
5class Character {/*...*/};
14
15auto GetRenamer() {
16  return std::mem_fn(&Character::SetName);
17}
18
19int main() {
20  auto Rename{GetRenamer()};
21
22  Character Player;
23  Rename(Player, "Anna");
24  std::cout << "Name: " << Player.Name;
25}

1Anna

This can include binding if necessary:

1#include <functional>
2#include <string>
3#include <iostream>
4
5class Character {/*...*/};
14
15auto GetRenamer(Character& Player) {
16  return std::bind_front(
17    &Character::SetName, &Player);
18}
19
20int main() {
21  Character Player;
22
23  auto RenamePlayer{GetRenamer(Player)};
24  RenamePlayer("Anna");
25
26  std::cout << "Name: " << Player.Name;
27}

1Anna

When we have a member function that itself is returning a pointer to another member function of the same class, we can bind it to the this pointer. This ensures the returned function is called in the context of the same object that returned that function:

1#include <functional>
2#include <string>
3#include <iostream>
4
5class Character {
6 public:
7  auto GetRenamer() {
8    return std::bind_front(
9      &Character::SetName, this);
10  }
11
12  void SetName(std::string NewName) {
13    Name = NewName;
14  }
15
16  std::string Name;
17};
18
19int main() {
20  Character Player;
21
22  auto RenamePlayer{Player.GetRenamer()};
23  RenamePlayer("Anna");
24
25  std::cout << "Name: " << Player.Name;
26}

1Anna

Let’s see a more practical example. We’ll update the utility AI example we introduced in the previous lesson, but this time our actions are member functions.

Below, our Monster class has a SuggestAction() function. It returns a function pointer with its recommended action, and updates a Utility integer, estimating the usefulness of that action:

1// Monster.h
2#pragma once
3#include <functional>
4#include <iostream>
5
6class Monster {
7 public:
8  std::function<void()> SuggestAction(
9    int& Utility
10  ) {
11    if (canHeal()) {
12      Utility = 150;
13      return std::bind_front(
14        &Monster::Heal, this);
15    } else if (canAttack()) {
16      Utility = GetAttackDamage();
17      return std::bind_front(
18        &Monster::Attack, this);
19    } else {
20      Utility = 25;
21      return std::bind_front(
22        &Monster::RunAway, this);
23    }
24  }
25
26  void Heal() {
27    std::cout << "Healing...\n";
28  }
29  void Attack() {
30    std::cout << "Attacking...\n";
31  }
32  void RunAway() {
33    std::cout << "Running away...\n";
34  }
35
36 private:
37  bool canHeal() { return false; }
38  bool canAttack() { return false; }
39  int GetAttackDamage() { return 100; }
40};

Elsewhere in our code, we can ask a Monster what action it recommends, but only perform that action if it would be sufficiently impactful:

1#include <iostream>
2#include "Monster.h"
3
4void Act(Monster& Enemy) {
5  int Utility;
6  auto Action{Enemy.SuggestAction(Utility)};
7
8  if (Utility >= 100) {
9    Action();
10  } else {
11    std::cout << "Utility (" << Utility
12      << ") is too low, taking no action\n";
13  }
14}
15
16int main() {
17  Monster Enemy;
18  Act(Enemy);
19}

1Utility (25) is too low, taking no action

Summary

In this lesson, we expanded our knowledge of function pointers to include pointers to member functions. We covered:

Creating pointers to static and non-static member functions
Using std::mem_fn() to create callable objects from member function pointers
Employing std::bind_front() for partial application of functions
Returning member function pointers from other functions
Practical applications in game development scenarios

Was this lesson useful?

Next Lesson

SDL2 Timers and Callbacks

Learn how to use callbacks with SDL_AddTimer() to provide functions that are executed on time-based intervals

New: AI-Powered AssistanceAI Assistance

Questions and HelpNeed Help?

Get instant help using our free AI assistant, powered by state-of-the-art language models.

Ryan McCombe

Posted 2 months ago

Lesson Contents