std::bind and std::reference_wrapper

std::bind and std::reference_wrapper

---

Prerequisites

---

1. What is a ‘std::bind’?

std::bind is a utility that allows you to bind arguments to a function and create a new callable object.

#include <functional>

auto f = std::bind(function, args...);

It transforms a function into a callable object with fixed or rearranged arguments

Use it when:

• You need compatibility with older APIs
• You want quick argument binding (rare nowadays)

Otherwise → use lambda

Example

#include <iostream>
#include <functional>

int add(int a, int b)
{
    return a + b;
}

int main()
{
    auto f = std::bind(add, 2, 3);

    std::cout << f();  // 5
}

Arguments are pre-bound

1-1. Placeholders (std::placeholders)

Used to represent arguments that will be passed later.

using namespace std::placeholders;

auto f = std::bind(add, _1, 10); // auto f = std::bind(add, std::placeholder::_1, 10);

std::cout << f(5);  // 15

_1, _2, … are placeholders

Argument Reordering

auto f = std::bind(add, _2, _1);

std::cout << f(3, 5);  // 8 (5 + 3)

1-2. Binding Member Functions

struct MyClass
{
    int multiply(int a, int b)
    {
        return a * b;
    }
};

MyClass obj;

auto f = std::bind(&MyClass::multiply, &obj, 2, 3);

std::cout << f();  // 6

1-3. Common Pitfall: Copy vs Reference

int x = 10;

auto f = std::bind([](int v)
{
    std::cout << v;
}, x);

x = 20;

f();  // prints 10 ❗

std::bind copies arguments by default

1-4. Performance Considerations

- std::bind vs Lambda

std::bind

• More complex
• Harder to optimize
• Less readable

auto f = std::bind(add, _1, 10);

Lambda (Recommended)

auto f = [](int x)
{
    return add(x, 10);
};

Modern compilers:

• Inline aggressively
• Generate better code

Lambda is:

• clearer
• faster
• preferred in modern C++

Performance Comparison

Method	Performance	Readability
Lambda	🔥 Fast	✅ High
std::bind	⚡ Medium	❌ Low

2. What is std::reference_wrapper?

std::reference_wrapper allows you to store references inside standard containers or bind

#include <functional>

std::reference_wrapper<int> ref = x;

It behaves like a reference but is copyable

Use it when:

• You need to store references in containers

std::vector<std::reference_wrapper<int>> v;

• You need reference semantics in std::bind or std::function

✔️ Fixing the Copy Issue

int x = 10;

auto f = std::bind([](int& v)
{
    std::cout << v;
}, std::ref(x));

x = 20;

f();  // prints 20 ✅

std::ref(x) ensures reference semantics

std::ref and std::cref

Function	Description
std::ref(x)	reference
std::cref(x)	const reference