Skip to main content

Chapter 36: Bind Mem Fn and Invoke

核心问题与阅读主线

本章导读7 个核心小节 · 附自检与总结

C++ 中普通函数、函数对象、lambda 与成员指针的调用语法各异,泛型与回调代码需要统一的可调用性(callable)判定与转发模型。本章围绕 std::bind、std::placeholders、std::mem_fn 与 std::invoke,拆解状态保存、实参槽位映射、成员接收者规则及现代 C++ 中 lambda 的替代边界。

全章共用代码样本(下文各节持续拆解)

贯穿材料核心代码

本章以一组贯穿全章的最小样本串起各节:Job 持有任务状态并暴露读写成员,combine 负责组合三路整型参数。

#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>

struct Job {
int base = 10;

int score(int bonus) const {
return base + bonus;
}

void add(int delta) {
base += delta;
}
};

int combine(int left, int middle, int right) {
return left * 100 + middle * 10 + right;
}

36.1 std::bind​

std::bind 接收可调用对象与绑定参数,返回一个未指定类型的函数对象(bind expression,标准仅约定其行为与 std::is_bind_expression 等 trait 结果),调用时再把保存槽位与当次实参合成为目标调用。

下面固定 combine 的中间参数,并用占位符重排未来实参顺序:

#include <functional>
#include <iostream>

int combine(int left, int middle, int right) {
return left * 100 + middle * 10 + right;
}

int main() {
using namespace std::placeholders;

auto adapter = std::bind(combine, _2, 7, _1);
std::cout << adapter(3, 4) << '\n'; // combine(4, 7, 3) -> 473
}

std::bind 内部按 std::decay_t 保存目标函数与各绑定参数(去引用,数组与函数类型转为指针);普通绑定参数默认在创建时拷贝或移动进包装器。

直接传值与通过 std::ref 传引用会表现出不同的观测结果:

#include <functional>
#include <iostream>

void print_pair(int current, int captured) {
std::cout << current << ',' << captured << '\n';
}

int main() {
using namespace std::placeholders;

int value = 1;
auto by_value = std::bind(print_pair, _1, value);
auto by_ref = std::bind(print_pair, _1, std::ref(value));

value = 9;
by_value(3); // 3,1
by_ref(3); // 3,9
}

std::bind 对四类绑定实参的保存与求值规则如下:

绑定实参类别包装器内部保存形态调用时如何进入目标调用
std::reference_wrapper<T>(std::ref / std::cref)保存引用包装器对象通过 get() 取出原对象引用
嵌套 bind expression(std::is_bind_expression)保存子包装器对象先用当次实参求值,再将结果传给外层
placeholder(_1, _2, ...)保存位置占位符按索引提取当次调用对应位置的实参
其他普通参数按 std::decay_t 拷贝或移动保存以内部保存的副本对象参与目标调用

边界与误区

注意

普通绑定参数默认按衰变副本保存,创建后修改外部变量不会同步生效;若改用 std::ref / std::cref 传递引用语义,调用方必须保证原对象生命周期长于 bind expression。

关键事实

std::bind 将调用配置封装为可存入 std::function 或回调接口的对象,代价是成员存储、包装层间接调用以及参数映射脱离调用点。

36.2 std::placeholders​

std::placeholders 提供 _1、_2、_3 等占位符:_N 指定从当次调用的第 N 个实参取值,而占位符在绑定列表中的位置决定该实参落入目标函数的哪个形参槽位。

下面用占位符反转 combine 的参数顺序,并固定中间槽位:

#include <functional>
#include <iostream>

int combine(int left, int middle, int right) {
return left * 100 + middle * 10 + right;
}

int main() {
using namespace std::placeholders;

auto reversed = std::bind(combine, _3, _2, _1);
auto fixed_middle = std::bind(combine, _2, 5, _1);

std::cout << reversed(1, 2, 3) << '\n'; // combine(3, 2, 1) -> 321
std::cout << fixed_middle(8, 4, 99) << '\n'; // combine(4, 5, 8) -> 458
}

关键事实

fixed_middle(8, 4, 99) 中未被任何占位符选中的第三个实参 99 仍会完成求值后再被丢弃;该规则常用于将多参数回调接口适配给只关心部分参数的业务函数。

同一占位符可重复出现,将同一个当次实参分发到多个只读或廉价拷贝形参:

#include <functional>
#include <iostream>
#include <string>

void show_twice(const std::string& left, const std::string& right) {
std::cout << left << ':' << right << '\n';
}

int main() {
using namespace std::placeholders;

auto twice = std::bind(show_twice, _1, _1);
std::string name = "build";
twice(name); // show_twice(name, name)
}

边界与误区

注意

placeholder 只映射位置,不表达资源策略。若目标形参要求独立的 move-only 对象或会消耗右值,重复 _1, _1 会把同一资源送入多个槽位,导致编译失败或语义异常;涉及所有权转移时应改用 lambda 显式处理。

排查顺序

  1. 看目标形参:先确认目标函数或成员函数的签名与形参顺序。
  2. 核对绑定槽位:逐槽位区分普通衰变值、std::ref 与 _N 占位符。
  3. 映射当次实参:将调用实参按 _N 填入目标槽位,未被引用的实参按求值后丢弃处理。

36.3 std::mem_fn​

成员指针原生调用依赖 .* 或 ->*,无法直接传入通用算法;std::mem_fn 将成员指针包装为函数对象,把首个实参解释为接收者,后续实参透传给成员函数。

#include <functional>
#include <iostream>
#include <memory>

struct Job {
int base = 10;

int score(int bonus) const {
return base + bonus;
}
};

int main() {
Job job{20};
auto score = std::mem_fn(&Job::score);

std::cout << score(job, 3) << '\n'; // 23
std::cout << score(&job, 4) << '\n'; // 24

auto owned = std::make_shared<Job>(Job{30});
std::cout << score(owned, 5) << '\n'; // 35
}

边界与误区

注意

std::mem_fn 仅保存成员指针而不拥有目标对象。包装器本身可长期保存,接收者存活期由每次调用传入的首个实参(对象引用、裸指针或可解引用智能指针)负责。

包装成员数据指针时,传入接收者即可访问字段:接收者可修改时返回左值支持赋值,为 const 时受只读约束。

#include <functional>
#include <iostream>

struct Job {
int base = 10;
};

int main() {
Job job{12};
auto base = std::mem_fn(&Job::base);

std::cout << base(job) << '\n';
base(job) = 40;
std::cout << job.base << '\n';
}

std::mem_fn、lambda 与 std::function 的实现开销及定位差异如下:

包装形式内部保存内容类型擦除与开销典型适用场景
std::mem_fn仅成员指针,按 INVOKE 转发保留具体类型,零堆分配成员指针来自模板参数或萃取结果,直接适配算法
lambda显式捕获与自定义调用体保留唯一闭包类型,易内联业务层字段提取(如 [](const Job& j) { return j.base; })或复合逻辑
std::function任意兼容签名的可调用对象运行时类型擦除,可能引入间接调用与堆分配回调表、事件槽等需要统一运行时类型的存储位

36.4 std::invoke​

std::invoke(C++17,<functional>)按标准 INVOKE 规则统一派发普通可调用对象与成员指针:

调用目标 f 类型等价底层语义首个实参角色后续实参
普通函数 / 函数对象 / lambdaf(args...)目标的第一个实参其余实参
成员函数指针(obj.*pmf)(args...) / (ptr->*pmf)(args...)接收者(对象、reference_wrapper、指针或智能指针)成员函数形参
成员数据指针obj.*pmd / ptr->*pmd接收者(仅允许传入该唯一实参)无

普通函数、函数对象与 lambda 的统一调用:

#include <functional>
#include <iostream>

int twice(int value) {
return value * 2;
}

struct PlusOne {
int operator()(int value) const {
return value + 1;
}
};

int main() {
auto lambda = [](int value) { return value - 3; };

std::cout << std::invoke(twice, 5) << '\n';
std::cout << std::invoke(PlusOne{}, 5) << '\n';
std::cout << std::invoke(lambda, 5) << '\n';
}

成员函数指针与成员数据指针(首个实参均为接收者):

#include <functional>
#include <iostream>

struct Job {
int base = 10;

int score(int bonus) const {
return base + bonus;
}
};

int main() {
Job job{20};

std::cout << std::invoke(&Job::score, job, 3) << '\n'; // (job.*pmf)(3)
std::cout << std::invoke(&Job::score, &job, 4) << '\n'; // (ptr->*pmf)(4)
std::cout << std::invoke(&Job::base, job) << '\n'; // job.*pmd
}

模板中直接写 f(args...) 会排斥成员指针,标准做法是结合 std::invoke 与可调用性 trait 构建转发骨架:

#include <functional>
#include <type_traits>
#include <utility>

template<class F, class... Args>
decltype(auto) call_once(F&& f, Args&&... args)
noexcept(std::is_nothrow_invocable_v<F, Args...>)
{
static_assert(std::is_invocable_v<F, Args...>);
return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
}

call_once 展示了泛型调用包装器的四个基础原语:

  • 合法性校验:std::is_invocable_v<F, Args...> 在编译期校验完整调用表达式是否成立。
  • 异常承诺透传:std::is_nothrow_invocable_v<F, Args...> 让外层 noexcept 精确跟随底层调用。
  • 返回类型与类别:std::invoke_result_t<F, Args...> 推导返回类型,decltype(auto) 保留值类别。
  • 统一转发执行:std::invoke(std::forward<F>(f), std::forward<Args>(args)...) 统一派发普通对象与成员指针。

核心判断

编写接收任意 callable 的模板时,统一用 std::invoke 替代 f(args...),才能在不拆分支的前提下同时兼容函数对象与成员指针。

36.5 成员函数调用统一化​

成员函数指针仅描述类内成员位置而不保存对象,统一调用由首实参提供接收者,支持对象引用、std::reference_wrapper、裸指针与可解引用智能指针四类形态:

#include <functional>
#include <iostream>
#include <memory>

struct Job {
int base = 10;

int score(int bonus) const {
return base + bonus;
}
};

int main() {
auto pmf = &Job::score;

Job job{10};
auto ref = std::ref(job);
auto ptr = &job;
auto owned = std::make_unique<Job>(Job{30});

std::cout << std::invoke(pmf, job, 1) << '\n'; // object
std::cout << std::invoke(pmf, ref, 2) << '\n'; // reference_wrapper
std::cout << std::invoke(pmf, ptr, 3) << '\n'; // pointer
std::cout << std::invoke(pmf, owned, 4) << '\n'; // smart pointer through dereference
}

统一调用不放宽成员函数自身的限定约束:const 与非 const 成员函数分别匹配只读与可修改接收者,带 & / && ref-qualifier 的成员函数还会严格校验接收者的值类别。

#include <functional>
#include <utility>

struct Counter {
int value = 0;

int get() const {
return value;
}

void add(int delta) {
value += delta;
}

int finish() && {
return value;
}
};

int main() {
Counter counter{1};
const Counter frozen{2};

std::invoke(&Counter::get, frozen);
std::invoke(&Counter::add, counter, 3);
std::invoke(&Counter::finish, Counter{4});

// std::invoke(&Counter::add, frozen, 3); // const 接收者不匹配
// std::invoke(&Counter::finish, counter); // 需要右值接收者
}

排查顺序

  1. 辨别成员指针:区分指向成员函数还是成员数据(后者仅接受单个接收者实参)。
  2. 解析接收者形态:检查首实参是类/派生类对象、std::reference_wrapper,还是需解引用的指针/智能指针。
  3. 校验限定约束:核对接收者是否满足成员函数的 const、volatile 与引用限定(& / &&)。
  4. 匹配成员实参:针对成员函数,检查后续实参数量与类型能否传入目标形参。

关键事实

std::bind(&Job::score, _1, 5) 与 std::mem_fn(&Job::score) 在接收者解析与限定校验上均沿用同源的 INVOKE 规则。

36.6 callable 统一模型​

泛型算法面对未知的 F 时,callable 统一模型拆分为三个协同层次:

模型层次核心组件职责边界
表达式层std::invoke统一普通可调用对象与成员指针的调用语法
trait / 约束层std::is_invocable、std::invoke_result、std::invocable检查完整调用是否成立,推导返回类型与异常属性
包装器 / 适配层lambda、std::bind、std::mem_fn、std::function按需保存调用配置、映射槽位或做运行时类型擦除

project_one 在约束层校验“投影器能否以单个对象调用”,并在表达式层用 std::invoke 派发:

#include <functional>
#include <type_traits>
#include <utility>

template<class Proj, class T>
requires std::is_invocable_v<Proj, T>
decltype(auto) project_one(Proj&& proj, T&& value)
{
return std::invoke(std::forward<Proj>(proj), std::forward<T>(value));
}

以 Job 测试可见 trait 校验的是完整调用表达式(含目标、接收者、额外参数、返回类型与异常属性):

  • project_one(&Job::base, job):成立,成员数据指针配合单个接收者满足调用。
  • project_one([](const Job& j) { return j.base; }, job):成立,一元 lambda 匹配签名。
  • project_one(std::mem_fn(&Job::score), job):不成立,score 缺少第二个 int bonus 实参,在约束层被拦截。

以下示例把成员数据指针、成员函数指针与 lambda 统一传入 call_checked:

#include <functional>
#include <iostream>
#include <type_traits>
#include <utility>

struct Job {
int base = 10;

int score(int bonus) const {
return base + bonus;
}
};

template<class F, class... Args>
requires std::is_invocable_v<F, Args...>
decltype(auto) call_checked(F&& f, Args&&... args)
{
return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
}

int main() {
Job job{20};

std::cout << call_checked(&Job::base, job) << '\n';
std::cout << call_checked(&Job::score, job, 5) << '\n';
std::cout << call_checked([](int x) { return x * 2; }, 7) << '\n';
}

不同 C++ 标准版本下,工具与模板约束的写法边界如下:

标准版本引入的核心工具模板约束典型写法
C++11std::bind、std::placeholders、std::mem_fn仅提供调用包装器,无标准 invoke 与 is_invocable
C++17std::invoke、std::is_invocable、std::invoke_resultstd::is_invocable_v 配合 std::enable_if_t、if constexpr 或 static_assert
C++20std::invocable concept直接将 std::invocable 写入 requires 或模板形参约束
C++23std::invoke_r显式指定或转换返回类型(含按需丢弃返回值)

核心判断

  1. 评估是否保存配置:需延迟调用或捕获参数时,在 lambda、std::bind、std::mem_fn、std::function 中选型。
  2. 评估是否类型擦除:仅当需统一异构回调的运行时类型时,才引入 std::function。
  3. 统一模板调用入口:泛型代码默认通过 std::invoke 兼容成员指针。
  4. 前置可调用性约束:用 std::is_invocable 或 C++20 std::invocable 校验完整实参表。
  5. 透传返回与异常:用 decltype(auto) 与 std::is_nothrow_invocable_v 保留值类别与 noexcept 属性。

36.7 为什么现代 C++ 更推荐 lambda​

lambda 将捕获状态、形参列表与转发逻辑内聚在同一语法结构内,所有权与映射一目了然;std::bind 则将这些信息分散在绑定列表、占位符与调用实参之间。

等价改写后,lambda 显式命名了形参并明确丢弃额外参数 extra:

#include <functional>
#include <iostream>

int combine(int left, int middle, int right) {
return left * 100 + middle * 10 + right;
}

int main() {
using namespace std::placeholders;

auto by_bind = std::bind(combine, _2, 7, _1);
auto by_lambda = [](int first, int second, int extra) {
static_cast<void>(extra);
return combine(second, 7, first);
};

std::cout << by_bind(3, 4, 99) << '\n';
std::cout << by_lambda(3, 4, 99) << '\n';
}

资源捕获方面,lambda 原生支持 [value]、[&value] 与 C++14 初始化捕获,能直接完成 move-only 对象的所有权转移:

#include <iostream>
#include <memory>

struct Job {
int base = 10;
};

int main() {
auto owned = std::make_unique<Job>(Job{42});

auto reader = [job = std::move(owned)]() {
return job->base;
};

std::cout << reader() << '\n';
}

现代工程中四类调用工具的分层定位如下:

工具核心定位优势适用边界
lambda局部调用适配器捕获、签名与控制流内聚,支持 init-capture 转移所有权现代业务代码与回调适配首选
std::mem_fn成员指针包装器无类型擦除、表达紧凑,与 INVOKE 语义对齐成员指针来自模板参数或类型萃取,直接传入算法
std::bind参数绑定包装器对象化参数配置,兼容依赖 bind expression trait 的旧接口维护存量代码或极简无状态参数重排
std::invoke统一调用底层原语一套规则覆盖普通函数、函数对象与成员指针泛型库与高阶模板内部统一执行

核心判断

四者职责分层清晰:业务适配首选 lambda,成员指针短适配可用 std::mem_fn,旧接口或简单重排保留 std::bind,模板库统一执行则用 std::invoke 配合可调用性 trait。

最小自检任务​

动手自检先独立判断

阅读下面代码,判断每个调用最终对应哪一次底层调用,并说明哪些对象在创建包装器时被保存,哪些对象在调用时才提供。

#include <functional>
#include <iostream>

struct Job {
int base = 10;

int score(int bonus) const {
return base + bonus;
}
};

int combine(int left, int middle, int right) {
return left * 100 + middle * 10 + right;
}

int main() {
using namespace std::placeholders;

Job job{20};
auto a = std::bind(combine, _2, 6, _1);
auto b = std::bind(&Job::score, _1, 5);
auto c = std::mem_fn(&Job::base);

std::cout << a(3, 4, 99) << '\n';
std::cout << b(job) << '\n';
std::cout << c(job) << '\n';
std::cout << std::invoke(&Job::score, job, 7) << '\n';
}

本章知识点总结​

  • std::bind 与参数衰变

    将目标对象与参数按 std::decay_t 拷贝或移动保存为未指定类型的包装器,引用语义须显式使用 std::ref / std::cref(且须保证原对象生命周期)。

  • std::placeholders 映射

    _N 从当次调用第 N 个实参取值并送到绑定槽位;未选中的多余实参仍会求值后丢弃,重复占位符慎用于 move-only 或消耗型右值。

  • std::mem_fn 包装成员指针

    轻量保存成员函数或成员数据指针且不做类型擦除,将首个实参作为接收者按 INVOKE 规则转发,不拥有目标对象生命周期。

  • std::invoke 统一调用

    C++17 起统一普通可调用对象与成员指针调用;成员指针首实参支持对象、std::reference_wrapper、指针与可解引用智能指针,且严格校验 cv 与引用限定。

  • 可调用性 Trait 与约束

    泛型模板以 std::invoke 执行调用,配合 std::is_invocable_v(或 C++20 std::invocable)、std::invoke_result_t、std::is_nothrow_invocable_v 与 decltype(auto) 校验并透传调用属性。

  • 标准版本演进

    bind、placeholders、mem_fn 属 C++11,invoke 与 invocable trait 属 C++17,std::invocable 概念属 C++20,std::invoke_r 属 C++23。

  • 现代工程选型

    业务局部适配与所有权转移(含 init-capture)首选 lambda,成员指针直传可用 std::mem_fn,旧接口或简单重排保留 std::bind,模板库统一执行底层使用 std::invoke。