Binding and std::ref / std::cref

std::ref and std::cref are utility functions provided by the <functional> header that enable passing references to objects when using std::bind. These functions are particularly useful to avoid copying objects when binding them to a function.

Here's an example demonstrating how to use std::ref with std::bind:

1#include <functional>
2#include <iostream>
3
4void SetValue(int& value, int newValue) {
5  value = newValue; }
6
7int main() {
8  int value = 10;
9
10  auto SetValue10 = std::bind(
11    SetValue, std::ref(value), 10);
12
13  auto SetValue20 = std::bind(
14    SetValue, std::ref(value), 20);
15
16  SetValue10();
17  std::cout << "Value after SetValue10: "
18    << value << '\n';
19
20  SetValue20();
21  std::cout << "Value after SetValue20: "
22    << value << '\n';
23}

1Value after SetValue10: 10
2Value after SetValue20: 20

In this example:

• The SetValue function takes a reference to an int and a new value, updating the int with the new value.
• We create two bound function objects, SetValue10 and SetValue20, using std::bind. Here, std::ref(value) ensures that SetValue receives a reference to value rather than a copy.
• When SetValue10 and SetValue20 are called, they modify the original value variable.

Similarly, std::cref can be used to bind a const reference to an object, which is useful when you want to bind a reference to a const object or a temporary object that should not be modified.

Here's an example demonstrating std::cref:

1#include <functional>
2#include <iostream>
3#include <string>
4
5void PrintString(const std::string& str) {
6  std::cout << str << '\n'; }
7
8int main() {
9  std::string tempStr = "Hello";
10  auto Print = std::bind(
11    PrintString, std::cref(tempStr));
12
13  Print();
14}

1Hello

In this example:

• The PrintString function takes a const reference to a std::string and prints it.
• We create a temporary std::string object tempStr with the value "Hello".
• We use std::cref(tempStr) to bind a const reference to tempStr.
• The Print functor, when called, passes this const reference to PrintString, which prints the string.

By using std::cref, we ensure that the std::string object is not copied and is passed as a const reference to the bound function.

In summary, std::ref and std::cref are valuable tools for binding references to functions with std::bind, allowing you to avoid unnecessary object copying and maintain the integrity of the original objects.