Function Binding and Partial Application

Earlier in the chapter, we introduced the concept of partial application. With partial application, we provide only some of a function’s required arguments - the remaining arguments are provided later, elsewhere in our code.

Being able to implement this approach gives us more flexibility in our designs, and is sometimes required. We introduced an example where we wanted to determine if a Player object was a minimum level but, because of constraints in our design, we were not able to provide the Player and MinimumLevel at the same time.

We solved this using a functor. We provided the MinLevel as a constructor argument, where it then got saved to a member variable. We then later provided the Player object as an argument to the () operator.

A simplified implementation of the full example we introduced in the Functors lesson is below:

1#include <iostream>
2
3struct Player {
4  int GetLevel() const { return 45; }
5};
6
7struct LevelChecker {
8  int MinLevel {50};
9  bool operator()(const Player& P) {
10    return P.GetLevel() >= MinLevel;
11  }
12};
13
14int main() {
15  Player PlayerOne;
16  LevelChecker IsLevel40{40};
17  LevelChecker IsLevel50{50};
18
19  if (IsLevel40(PlayerOne)) {  
20    std::cout << "Player is level 40 or above";
21  }
22
23  if (!IsLevel50(PlayerOne)) {
24    std::cout << "\nBut not level 50 or above";
25  }
26}

1Player is level 40 or above
2But not level 50 or above

In this lesson, we’ll cover a more direct and flexible way of implementing partial application, using std::bind.

Binding and std::bind()

To support the partial application of a function, we can imagine generating a simple wrapper around that function. When creating the wrapper, we provide some (but not all) of the arguments that the function needs.

The wrapper can overload the () operator, thereby creating a function object (a functor) that we can call. When the functor is called, the caller provides the remaining arguments.

The functor then combines the arguments provided at its construction (the "bound" arguments) with the arguments provided to the () operator to invoke the underlying function.

Let's imagine we have the following function, that accepts three arguments:

1#include <iostream>
2
3void Func(int x) {
4  std::cout << "x = " << x << '\n';
5}
6
7int main() {
8  Func(1);
9}

1x = 1

We can use std::bind() from the <functional> header to create a functor wrapping this function:

1#include <iostream>
2#include <functional>
3
4void Func(int x) {
5  std::cout << "x = " << x << '\n';
6}
7
8int main() {
9  auto Functor{std::bind(Func, 1)};
10  Functor();
11}

1x = 1

We can bind multiple arguments by providing them when creating the functor:

1#include <iostream>
2#include <functional>
3
Unchanged Code|Show
4void Func(int x, int y, int z) {/*...*/}
10
11int main() {
12  auto Functor{std::bind(Func, 1, 2, 3)};
13  Functor();
14}

1x = 1, y = 2, z = 3

The functor is also reusable - we can call it as many times as needed:

1#include <iostream>
2#include <functional>
3
Unchanged Code|Show
4void Func(int x, int y, int z) {/*...*/}
10
11int main() {
12  auto Functor{std::bind(Func, 1, 2, 3)};
13  Functor();
14  Functor();
15  Functor();
16}

1x = 1, y = 2, z = 3
2x = 1, y = 2, z = 3
3x = 1, y = 2, z = 3

Partial Application

Binding all of a function’s arguments is sometimes useful, but more commonly we’ll only want to bind some. This allows other arguments to be provided when we later invoke our functor.

We’ll cover how to do this using std::bind() later in the lesson, but C++20 and C++23 introduced std::bind_front() and std::bind_back() respectively, which are easier to use and capture most use cases.

std::bind_front()

When we want to bind the leftmost arguments in a function’s parameter list and let the later arguments be provided separately, we can use std::bind_front().

Below, we bind the x value of Func() to 1, and let the y and z be provided later:

1#include <iostream>
2#include <functional>
3
Unchanged Code|Show
4void Func(int x, int y, int z) {/*...*/}
10
11int main() {
12  auto Functor{std::bind_front(Func, 1)};
13
14  Functor(2, 3);
15  Functor(5, 9);
16  Functor(42, 97);
17}

1x = 1, y = 2, z = 3
2x = 1, y = 5, z = 9
3x = 1, y = 42, z = 97

In this example, we bind both x and y, requring only z to be provided later:

1#include <iostream>
2#include <functional>
3
Unchanged Code|Show
4void Func(int x, int y, int z) {/*...*/}
10
11int main() {
12  auto Functor{std::bind_front(Func, 1, 2)};
13
14  Functor(3);
15  Functor(9);
16  Functor(97);
17}

1x = 1, y = 2, z = 3
2x = 1, y = 2, z = 9
3x = 1, y = 2, z = 97

std::bind_back()

Note*: std::bind_back() is a C++23 feature, and may not yet be available in all compilers. The behavior can be replicated using std::bind and std::placeholders in older specifications, which we cover below.*

The std::bind_back() function works in the opposite way to std::bind_front(). It lets us bind arguments at the end of our parameter list, leaving the leftmost arguments to be provided later. Below, we bind y to 2 and z to 3, with x being provided by the caller.

1#include <iostream>
2#include <functional>
3
Unchanged Code|Show
4void Func(int x, int y, int z) {/*...*/}
10
11int main() {
12  auto Functor{std::bind_back(Func, 2, 3)};
13
14  Functor(1);
15  Functor(0);
16  Functor(-5);
17}

1x = 1, y = 2, z = 3
2x = 0, y = 2, z = 3
3x = -5, y = 2, z = 3

Using std::placeholders

Whilst the std::bind_front() and std::bind_back() functions can satisfy most use cases, there are more complex scenarios where we need a bit more flexibility. We can implement these using a combination of std::bind() and std::placeholders

Within our std::bind() argument list, we can use identifiers within the std::placeholders namespace to mark locations where future arguments will go. We have access to std::placeholders::_1, std::placeholders::_2, and so on.

When we later call our functor, the first argument we pass will be forwarded to where we placed std::placeholders::_1, the second will be forwarded to std::placeholders::_2, and so on.

Below, we reimplement our std::bind_front(Func, 1) example using these techniques. We bind the first argument of Func() to the integer 1, but leave placeholders for the remaining two parameters. We can then provide those when calling the functor:

1#include <iostream>
2#include <functional>
3
Unchanged Code|Show
4void Func(int x, int y, int z) {/*...*/}
10
11int main() {
12  auto Functor{std::bind(Func, 1,
13    std::placeholders::_1,
14    std::placeholders::_2
15  )};
16
17  Functor(2, 3);
18  Functor(5, 9);
19  Functor(42, 97);
20}

1x = 1, y = 2, z = 3
2x = 1, y = 5, z = 9
3x = 1, y = 42, z = 97

In this example, we introduce a using namespace declaration for std::placeholders. We also bind the second argument of our underlying function, allowing the first and third to be provided later:

1#include <iostream>
2#include <functional>
3
Unchanged Code|Show
4void Func(int x, int y, int z) {/*...*/}
10
11int main() {
12  using namespace std::placeholders;
13  auto Functor{std::bind(Func, _1, 100, _2)};
14
15  Functor(0, 200);
16  Functor(200, 0);
17}

1x = 0, y = 100, z = 200
2x = 200, y = 100, z = 0

Reordering Arguments

Our placeholders do not have to be in ascending order. In this example, we don’t bind any arguments. Instead, we position our placeholders such that we create a functor that receives the same arguments as the underlying function, but in a different order:

1#include <iostream>
2#include <functional>
3
Unchanged Code|Show
4void Func(int x, int y, int z) {/*...*/}
10
11int main() {
12  using namespace std::placeholders;
13  auto Functor{std::bind(Func, _3, _2, _1)};
14
15  Functor(1, 2, 3);
16}

1x = 3, y = 2, z = 1

Binding a Member Function

We can use std::bind() with member functions. When using this technique, we can treat the object that the member function will be called on as the first argument.

If the member function has any additional arguments, we would also provide those, either as bound values, or std::placeholder markers.

Below, we create a functor that, when invoked, behaves like a call to PlayerOne.GetName():

1#include <iostream>
2#include <functional>
3
Player Struct|Show
4struct Player {/*...*/};
16
17int main() {
18  Player PlayerOne{"Roderick"};
19
20  auto GetPlayerName{
21    std::bind(&Player::GetName, &PlayerOne)};
22
23  std::cout << "Player: " << GetPlayerName();
24}

1Player: Roderick

The object the member function is called upon can also be a placeholder, allowing std::bind() to act as an alternative to std::mem_fn():

1#include <iostream>
2#include <functional>
3
Player Struct|Show
4struct Player {/*...*/};
16
17int main() {
18  Player PlayerOne{"Roderick"};
19
20  auto GetPlayerName{std::bind(&Player::GetName,
21    std::placeholders::_1)};
22
23  std::cout << "Player: "
24    << GetPlayerName(&PlayerOne);
25}

1Player: Roderick

Binding the Context Object

When binding a member function pointer, std::bind() allows us to provide the context object either as a value or a pointer, including a smart pointer.

Below, we pass a pointer to our context object. When the functor created by std::bind() is later invoked, it will visit that pointer to get the current state of our object:

1#include <iostream>
2#include <functional>
3
Player Struct|Show
4struct Player {/*...*/};
16
17int main() {
18  Player PlayerOne{"Roderick"};
19
20  auto GetPlayerOneName{std::bind(
21    &Player::GetName,
22    &PlayerOne // Passing by pointer 
23  )};
24
25  std::cout << "Name: "
26    << GetPlayerOneName();
27
28  PlayerOne.SetName("Anna");
29
30  std::cout << "\nName: "
31    << GetPlayerOneName();
32}

1Name: Roderick
2Name: Anna

We can alternatively bind by value, copying the context object into the functor created by std::bind(). When we later invoke the functor, it will use that copy, in the state it was when we bound it:

1#include <iostream>
2#include <functional>
3
Player Struct|Show
4struct Player {/*...*/};
16
17int main() {
18  Player PlayerOne{"Roderick"};
19
20  auto GetPlayerOneName{std::bind(
21    &Player::GetName,
22    PlayerOne   // Passing by value
23  )};
24
25  std::cout << "Name: "
26    << GetPlayerOneName();
27
28  PlayerOne.SetName("Anna");
29
30  std::cout << "\nName: "
31    << GetPlayerOneName();
32}

1Name: Roderick
2Name: Roderick

Using std::bind_front() and std::bind_back()

We can also use std::bind_front() or std::bind_back() with member functions where applicable.

The previous examples could be written using std::bind_front() or std::bind_back(), removing the need for the explicit placeholder:

1#include <iostream>
2#include <functional>
3
Player Struct|Show
4struct Player {/*...*/};
16
17int main() {
18  Player PlayerOne{"Roderick"};
19
20  auto GetPlayerName{
21    std::bind_front(&Player::GetName)};
22
23  std::cout << "Player: "
24    << GetPlayerName(&PlayerOne);
25}

1Player: Roderick

In the following example, we use std::bind_front() to bind a member function that accepts an argument:

1#include <iostream>
2#include <functional>
3
Player Struct|Show
4struct Player {/*...*/};
16
17int main() {
18  Player PlayerOne;
19
20  auto SetPlayerOneName{std::bind_front(
21    &Player::SetName, &PlayerOne)};
22
23  SetPlayerOneName("Anna");
24
25  std::cout << "Player: " << PlayerOne.GetName();
26}

1Player: Anna

Below, we modify the previous example to use std::bind_back(), thereby binding the member function’s Name parameter to "Anna", and accepting the Player we want to rename as an argument:

1#include <iostream>
2#include <functional>
3
Player Struct|Show
4struct Player {/*...*/};
16
17int main() {
18  Player PlayerOne;
19
20  auto SetNameToAnna{std::bind_back(
21    &Player::SetName, "Anna")};
22
23  SetNameToAnna(PlayerOne);
24
25  std::cout << "Player: " << PlayerOne.GetName();
26}

1Player: Anna

The previous examples could be implemented using std::bind() and std::placeholders if preferred:

1auto SetName{std::bind(&Player::SetName,
2  &PlayerOne, std::placeholders::_1)};
3
4auto SetNameToAnna{std::bind(&Player::SetName,
5  std::placeholders::_1, "Anna")};

A More Complex Example

Let’s go back to our Party code to see a more complex example closer to real problems we’re likely to solve by binding. Let's imagine we want everyone in our Party to start a Quest, We already have a StartQuest() function that comes close to meeting our needs, but not quite:

1#include <iostream>
2#include <concepts>
3#include <functional>
4
5struct Player { std::string Name; };
6struct Quest { std::string Name; };
7
Party Class|Show
8class Party {/*...*/};
22
23void StartQuest(Player& P, Quest& Q) {
24  std::cout << P.Name << " has started "
25    << Q.Name << '\n';
26}
27
28int main() {
29  Party MyParty;
30  Quest EpicQuest{"The Epic Quest"};
31
32  MyParty.for_each(/* ??? */); 
33}

Rather than writing a custom lambda or functor to integrate MyParty.for_each() and StartQuest(), we can instead bridge that gap using binding.

Below, we use std::bind_back() to create a functor that binds the EpicQuest parameter. The std::bind_back() function then returns a functor that accepts a single Player object as an argument, exactly what MyParty.for_each() requires.

Once it receives that argument, it forwards it to StartQuest(), and provides the EpicQuest we bound earlier as the second argument:

1#include <iostream>
2#include <concepts>
3#include <functional>
4
5struct Player { std::string Name; };
6struct Quest { std::string Name; };
7
Party Class|Show
8class Party {/*...*/};
22
StartQuest Function|Show
23void StartQuest(Player&, Quest&) {/*...*/}
28
29int main() {
30  Party MyParty;
31  Quest EpicQuest{"The Epic Quest"};
32
33  MyParty.for_each(std::bind_back(
34    StartQuest, EpicQuest 
35  ));
36}

1Anna has started The Epic Quest
2Robert has started The Epic Quest
3Roderick has started The Epic Quest

Prior to C++23, the previous example can be written using std::bind() and std::placeholders:

1MyParty.for_each(std::bind(
2  StartQuest, std::placeholders::_1, EpicQuest 
3));

Summary

In this lesson, we explored the concepts of function binding and partial application and the flexibility they provide when working with functions. The main things we covered include:

• A review of how user-defined functors can be used in partial application, illustrated with a Player and LevelChecker example.
• An Introduction to binding and std::bind() - a generic wrapper for creating functors that wrap some underlying function.
• Using std::bind_front() and std::bind_back() for easier binding of function arguments in C++20 and C++23.
• An introduction to std::placeholders for marking positions of future arguments in std::bind() calls.
• Various examples of binding member functions, thereby allowing them to be invoked as if they were free functions.
• Walking through a more complex example demonstrating the use of function binding in a practical scenario involving a Party class and a Quest structure.

Next Lesson

Trailing Return Types

An alternative syntax for defining function templates, which allows the return type to be based on their parameter types

ContinueView Course