C++11 新特性 ④ | 模板类 std::function 和标准库函数 std::bind

原创 已于 2025-06-07 10:14:36 修改 · 1.6w 阅读 · 40 ·
CC 4.0 BY-SA版权
本文为博主原创文章，未经博主允许不得转载。
文章标签：

#C++ #C++11 #C++11新特性 #function #bind

于 2023-09-09 10:41:23 首次发布
本文介绍了C++11中的std::function和std::bind，阐述了它们如何增强C++的灵活性。std::function提供了一种类型安全的方式来包装和调用可调用实体，而std::bind则允许预绑定函数参数，创建新的可调用对象。通过std::bind和std::function的组合，开发者可以更便捷地实现函数回调和定制化调用逻辑。
了解本专栏 订阅专栏 解锁全文
c++11标准库之模板类使用
10-06 317
定义模板类及模板类传入参数与默认参数 template<typename T1, typename T2 = vector<T1>> class MyClass { public: MyClass(); explicit MyClass(int a);//explicit只对只有一个参数的构造函数有效，指定为显示转换 MyClass(const MyClass& copyMyClass); MyClass(MyClass&& moveMyClass
现代C++的回调技术--使用std::bind和std::function
uufree的博客
03-12 5263
最近在读完陈硕大牛的《Linux多线程服务端编程》以及muduo源码后，对其中的一些实现细节有着十分深刻的印象，尤其是使用std::bind和std::function的回调技术。可以说，这两个大杀器简直就是现代C++的“任督二脉”，甚至可以解决继承时的虚函数指代不清的问题。在此详细叙述使用std::bind和std::function在C++对象之间的用法，用以配合解决事件驱动的编程模型。
std::bind和std::function
weixin_33827965的博客
12-27 153
　　std::bind 用于绑定一个函数，返回另外一种调用方式的函数对象 ，可以改变参数顺序 和个数，特别是在多线程的程序中，经常用它将函数进行包装，然后打包发送给工作线程，让工作线程去执行我们的任务。 　　std::function 用于构建一个函数特别是 回调函数  ，用于替代 函数指针/*常和匿名函数一起用回调*/ 参考以下代码： #include&lt;iostream&gt; ...
C++基础（11）类模板
qq_43685242的博客
07-09 1037
1. 类模板 类模板和函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同。 类模板用于实现类所需数据的类型参数化 #include<iostream> #include<string> using namespace std; //类模板和函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同。 //类模板用于实现类所需数据的类型参数化 template<class T1,
C++设计模式——一个基于C++11的万用单例模板类
weixin_34199405的博客
11-06 536
2019独角兽企业重金招聘Python工程师标准>>> ...
C++11类模板
dyxing_的博客
07-29 345
如下，和函数模板差不多都是在前面放个template里面用typename或者class定义个东东public:private:...在类外如果要实现类内函数的实现的话需要有如下写法template // 要加上这个 并且Demo写成这样Demo在类内不需要额外加东西。
c++11 类模板
Elsa的迷弟
01-20 861
类模板 将类中的某些类型变成泛型，从而定义一个模板。 类模板语法 声明 template<typename T> class Stack { public: Stack(); bool empty(); T peek(T value); T pop(); int getsize(); private: T elements[100]; int size; }; 定义 必须要使用模板前缀template<typename T>，而这个类必须用Stack<T&gt
【C++11】：std::function(包装器/适配器）
m0_66182473的博客
06-29 923
《C++ Primer》笔记
【std::function与STL组件】：探索std::function在C++标准库中的应用
![【std::function与STL组件】：探索std::...这使得我们可以将各种可调用实体（例如函数指针、lambda表达式、重载了调用操作符的类实例等）存储在同一个标准容器中，使代码更加灵活和简洁。本章节将首先介绍`std::
【C++】：bind绑定器和function函数对象机制
2301_79181030的博客
10-08 1170
这里，我创建了一个返回值为int，参数有两个，从左往右为int，int类型的函数指针。这些可调用对象的调用形式相同，甚至拥有相同的功能，但是却由于类型千差万别无法统一处理。例如，我们想要统一调用以上可调用对象，使用‘+’来调用add函数，而使用‘-’调用sub匿名函数…C++常见可调用对象有：函数、指针、匿名函数（lambda表达式）、函数对象（重载了函数调用运算符的类）以及使用bind创建的对象。如上，我们系统的介绍了function的使用方法和应用，但是它究竟是如何实现的呢？的基本用法有了初步的了解。
C++11 变长模板类
03-19
这个变长模板类，可以绑定任意类的任意方法，这个变长模板类，可以绑定任意类的任意方法。在实际调用时，只要创建这样一个父类(实际实现在子类中)，就可以在别的场合使用这个父类调用绑定的类的指定方法 开发环境是 VS2015(update3)
C++11特性详解：std::forward实现通用引用的最佳实践
C++11引入了一个新的引用类型——通用引用（universal reference），它在编程中扮演着非常重要的角色，特别是在泛型编程和函数模板中。通用引用的引入主要是为了解决完美转发（perfect forwarding）的问题，它允许...
std::bind与std::function
小吴同学的小屋
10-15 408
std::bind与std::function std::bind 调用std::bind的一般形式为 auto newCallable = bind(callable, arg_list); newCallable本身是一个可调用对象，arg_list是一个用逗号分隔的参数列表。当我们调用newCallable的时候会调用callable并且传给它arg_list里面的参数 std::bind是c++11的新特性，它接受一个可调用对象生成一个新的可调用对象来适应原对象的参数列表。举一个例子 bool
C++11的模版类array
渡辺麻友
02-07 1191
今天，Mayuyu来讲一个C++11中的模板类，即array。   在C++中，我们有vector可以很好地代替数组，且功能比较强大，但是vector的效率十分低下。如果需要使用长度 固定的数组，那么C++的普通数组是个很好地选择，但是缺点是使用起来很不方便，所以针对这种不足，C++11增加 了模板类array。它也是位于命名空间std中，跟数组一样，array的长度也是固定的，同样使用栈
【C++】 C++11 std::bind和std::function
最新发布
Antonio915的博客
08-20 715
本文介绍了C++11中的两个重要工具：std::function和std::bind。std::function是一个通用的函数包装器，可以存储和调用各种可调用对象（函数、lambda、成员函数等），提供统一的接口来处理不同类型的可调用对象。std::bind用于绑定可调用对象的参数，通过占位符调整参数顺序或固定部分参数，生成新的可调用对象。文章对比了lambda表达式和std::bind的参数适配能力，说明它们在不同场景下的使用方式。这两个工具简化了函数传递、存储和延迟调用的过程，提高了代码的灵活性和复用
std::bind和std::function详解
Watson2016的博客
10-20 3301
std::function 在看Cocos2d-x的范例代码时，随处可见“很奇怪”的语法： static std::functionLayer*()> createFunctions[] ={    CL(CameraTest1),    //...}; 其中CL是一个宏，对应如下lambda表达式： #define CL(__className__) [](){ retu
std::ref和std::reference_wrapper的原理
07-25
<think>我们正在深入探讨`std::ref`和`std::reference_wrapper`的内部原理和工作机制。这个问题涉及到C++标准库中引用语义的封装技术，对于理解函数对象绑定、线程参数传递等场景至关重要。 ### 核心问题：引用语义的封装 C++中引用本质上是别名，但引用本身不是对象（不能重新绑定，不占用存储空间）。当我们希望将引用作为对象传递时（如存入容器、绑定到函数对象），就需要`std::reference_wrapper`。它通过以下机制实现： 1. **存储指针**：内部持有指向目标对象的指针 2. **隐式转换**：提供到`T&`的隐式转换操作符 3. **可调用性**：重载`operator()`支持函数对象的直接调用 ### 实现原理分析 #### 1. 类定义框架 ```cpp template<typename T> class reference_wrapper { public: using type = T; // 构造函数：存储指针 explicit reference_wrapper(T& val) noexcept : ptr_(std::addressof(val)) {} // 禁止绑定到临时对象 reference_wrapper(T&&) = delete; // 隐式转换为原始引用类型 operator T& () const noexcept { return *ptr_; } // 显式获取引用 T& get() const noexcept { return *ptr_; } private: T* ptr_; // 核心：存储对象地址 }; ``` #### 2. `std::ref`的工厂函数 ```cpp template<typename T> reference_wrapper<T> ref(T& t) noexcept { return reference_wrapper<T>(t); } ``` ### 关键特性解析 | 特性 | 原理说明 | |---------------------|--------------------------------------------------------------------------| | **可复制/可赋值** | 类类型对象（非引用语义），支持拷贝和赋值操作 | | **可存储性** | 固定大小（通常为指针大小），可放入标准容器 | | **引用折叠处理** | 模板实例化时正确处理类型推导，避免引用折叠问题[^1] | | **生命周期安全** | 不延长目标对象生命周期，使用者需确保引用有效性 | | **多态支持** | 通过基类指针存储派生类对象，保持虚函数行为 | ### 工作流程示例 考虑以下使用场景： ```cpp void modify(int& x) { x *= 2; } int main() { int value = 42; auto bound = std::bind(modify, std::ref(value)); bound(); // value变为84 } ``` 执行过程： ```mermaid sequenceDiagram participant main as main() participant bind as std::bind participant ref as reference_wrapper participant modify as modify() main->>bind: 传递std::ref(value) bind->>ref: 存储value地址 main->>bound: 调用函数对象 bound->>ref: 解引用获取int& ref->>modify: 传递原始引用 modify->>value: 直接修改原始变量 ``` ### 与原始引用的核心区别 | 特性 | 原始引用 (`T&`) | `std::reference_wrapper<T>` | |-----------------------|----------------------|-----------------------------| | **重绑定** | 不可 | 可（通过赋值） | | **存储容器** | 不可 | 可 | | **类型大小** | 编译时不确定 | `sizeof(T*)` | | **默认构造** | 不可 | 可（需C++20） | | **模板类型推导** | 可能推导为值类型 | 保持引用语义 | ### 高级应用场景 1. **函数组合** ```cpp auto f = [](int x) { return x*2; }; auto g = [](int x) { return x+1; }; std::vector<std::reference_wrapper<decltype(f)>> funcs; funcs.push_back(f); funcs.push_back(g); ``` 2. **多态容器** ```cpp class Base { virtual void f(); }; class Derived : public Base {}; std::vector<std::reference_wrapper<Base>> poly_vec; Derived d; poly_vec.push_back(d); // 保持多态行为 ``` ### 常见误区 1. **绑定临时对象** ```cpp auto bound = std::bind(f, std::ref(42)); // 错误！临时对象立即销毁 ``` 正确做法：确保被引用对象生命周期长于引用包装器 2. **忽略类型转换** ```cpp void process(const std::string& s); char buffer[1024]; auto bound = std::bind(process, std::ref(buffer)); // 错误：类型不匹配 ``` 需要显式转换： ```cpp auto bound = std::bind(process, std::ref(static_cast<std::string&>(buffer))); // 仍然危险，需确保生命周期 ``` ### 性能特点 - **零开销抽象**：优化后与原始指针操作效率相同 - **内联友好**：编译器可完全优化掉包装层 - **无额外内存分配**：仅存储指针，不涉及堆分配 ### 标准演进 | 版本 | 改进要点 | |------------|---------------------------------------------| | C++11 | 首次引入 | | C++17 | 支持`constexpr` | | C++20 | 添加默认构造函数（需显式初始化） | | C++23 | 增强`operator()`的`constexpr`支持 | > **最佳实践**：在需要存储或传递引用语义的场景，优先使用`std::reference_wrapper`替代原始指针，可提供更清晰的类型表达和安全约束[^1]。 §§相关问题§§ 1. 如何在模板元编程中检测`std::reference_wrapper`类型？ 2. `std::reference_wrapper`与智能指针在函数绑定中的性能差异如何量化？ 3. C++20的`std::bind_front`相比`std::bind`在引用处理上有哪些改进？ 4. 为什么lambda捕获引用不需要`std::ref`包装？ 5. `std::reference_wrapper`如何影响函数重载决议？</think>### `std::ref` 与 `std::reference_wrapper` 的内部原理与工作机制 #### 核心设计目标 C++ 引用 (`T&`) 本质是**编译期别名**，无法直接存储或传递引用语义。`std::reference_wrapper` 通过**对象化封装**解决此问题： 1. 允许引用作为一等公民（可复制、可存储容器） 2. 保持引用语义（修改影响原对象） 3. 避免不必要的对象拷贝[^1] --- ### 一、内部实现原理 #### 1. 核心数据结构 ```cpp template<typename T> class reference_wrapper { public: using type = T; // 关键：存储原始对象的指针 explicit reference_wrapper(T& val) noexcept : ptr_(std::addressof(val)) {} // 隐式转换为原始引用类型 operator T& () const noexcept { return *ptr_; } // $ \text{转换操作符} $ // 显式获取引用 T& get() const noexcept { return *ptr_; } private: T* ptr_; // 核心存储：目标对象的指针 }; ``` #### 2. `std::ref` 工厂函数 ```cpp template<typename T> reference_wrapper<T> ref(T& t) noexcept { return reference_wrapper<T>(t); // $ \text{自动类型推导} $ } ``` --- ### 二、工作机制详解 #### 工作流程 ```mermaid graph LR A[调用 std::ref(obj)] --> B[构造 reference_wrapper] B --> C[存储 obj 的地址 &obj] C --> D[传递 reference_wrapper 对象] D --> E[隐式转换为 T& 类型] E --> F[操作原始对象 obj] ``` #### 关键特性： | 特性 | 原理说明 | |---------------------|--------------------------------------------------------------------------| | **可复制性** | 类类型对象（非引用语义），支持拷贝和赋值 | | **隐式类型转换** | `operator T&()` 使得在需要引用的场景自动转换 | | **存储安全性** | 存储指针而非引用，避免悬空引用风险（但需用户管理生命周期） | | **多态支持** | 通过基类指针存储派生类对象，保持虚函数行为 | --- ### 三、与标准库组件的交互 #### 1. 在 `std::bind` 中的行为 ```cpp void f(int& x) { x *= 2; } int main() { int val = 10; auto bound = std::bind(f, std::ref(val)); // $ \text{存储 reference\_wrapper} $ bound(); // 隐式转换为 int&，val 变为 20 } ``` - **无 `std::ref`**：`std::bind` 按值存储参数，创建副本 - **有 `std::ref`**：存储 `reference_wrapper`，调用时还原引用 #### 2. 在容器中的使用 ```cpp std::vector<std::reference_wrapper<int>> vec; int a=1, b=2; vec.push_back(a); vec.push_back(b); vec[0].get() = 10; // a 被修改为 10 ``` --- ### 四、编译器视角的转换 考虑以下代码： ```cpp void process(int& x); int main() { int n = 5; auto wrapper = std::ref(n); process(wrapper); // 编译器生成代码 } ``` 编译器实际处理： ```cpp // 编译器生成的等效代码 int n = 5; reference_wrapper<int> wrapper(n); process(wrapper.operator int&()); // 调用转换操作符 ``` --- ### 五、性能分析 1. **零开销抽象**： - 优化后与原始指针操作效率相同 - 无运行时类型检查（静态多态） ```cpp // 生成的汇编示例 (x86-64 GCC) mov rax, QWORD PTR [rbp-8] // 加载指针 mov DWORD PTR [rax], 10 // 直接操作内存 ``` 2. **与原始指针对比**： | 操作 | 原始指针 | `reference_wrapper` | |--------------------|---------------|--------------------| | 解引用访问 | `*ptr` | 隐式转换 | | 类型安全 | 弱 | 强（模板约束） | | 函数参数传递 | 需显式解引用 | 自动转换 | --- ### 六、特殊场景处理 #### 1. 常量性传播 ```cpp const int x = 10; auto ref = std::ref(x); // 类型推导为 reference_wrapper<const int> ref.get() = 20; // 编译错误：常量性保持 ``` #### 2. 函数对象支持 ```cpp auto lambda = [](int x) { return x*2; }; std::vector<std::reference_wrapper<decltype(lambda)>> funcs; funcs.push_back(lambda); // 存储可调用对象的引用 ``` --- ### 七、最佳实践与陷阱 1. **必须遵循**： ```cpp // 正确：绑定到左值 int x = 10; auto ref = std::ref(x); // 错误：绑定到临时对象 auto ref = std::ref(42); // 临时对象立即销毁！ ``` 2. **生命周期管理**： ```cpp std::function<void()> create_bound() { int local = 5; return std::bind(f, std::ref(local)); // 危险！local 将销毁 } // 返回的函数对象包含悬空引用 ``` --- ### 总结关键点 1. **存储本质**：内部持有 `T*`，通过转换操作符提供引用语义 2. **类型安全**：模板机制确保类型匹配 3. **零开销**：优化后等效指针操作 4. **应用场景**：函数绑定、容器存储引用、回调机制等需要引用语义的场合 > 在标准库函数（如 `std::bind`, `std::thread`）中传递引用时，**必须使用 `std::ref`** 明确表示引用语义，避免意外的对象拷贝[^1]。
评论 34
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dvlinker

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值