C++11 核心特性实战：Lambda、可变参数模板与函数包装器

• Args 表示一个包含零个或多个类型的参数包。
• args 也是参数包，里面可以是 0 或多个参数。
• ... 是展开参数包的操作（放在参数包后面，除了模板参数声明处）。
• 限制：参数包内部不支持直接索引访问，例如 arg[1] 是不支持的。

展开参数包的方法

1. 递归展开参数包
2. 逗号表达式展开参数包

应用场景

工厂函数示例

假设有一个日期类 Date，我们可以利用可变参数模板创建对象：

template<class... Args>
Date* Create(Args... args) {
    Date* ret = new Date(args...);
    return ret;
}

// 使用
Date* p1 = Create(2025, 9, 7);
Date d(2025, 9, 7);
Date* p2 = Create(d);

emplace_back vs push_back

STL 容器的 emplace_back 支持可变参数模板，而 push_back 不支持。

• emplace_back：可以直接传零散的参数进去，在容器内原地构造对象。
• push_back：必须先把零散参数搞成临时对象再传进去。

包装器

function 包装器

function 包装器也叫作适配器，需要头文件 #include <functional>。

它的主要作用是让可调用对象能够存储到容器中。其类模板原型如下：

template<class T> class function; // 声明
template<class Ret, class... Args>
class function<Ret(Args...)>;      // 具体特化

• Ret：被调用函数的返回类型。
• Args...：被调用函数的形参。

使用示例

#include <functional>
#include <vector>
#include <iostream>

double f(double i) { return i / 2; }

struct Functor {
    double operator()(double d) { return d / 3; }
};

int main() {
    // 第一个 double 是返回值类型，第二个 double 是形参类型
    std::vector<std::function<double(double)>> v = {
        f,
        [](double d) -> double { return d / 4; },
        Functor()
    };

    for (const auto& func : v) {
        std::cout << func(10.0) << std::endl;
    }
    return 0;
}

也可以将 function 对象放入 map 中：

std::map<std::string, std::function<int(int)>> map1 = {
    {"a", [](int x) { return x; }},
    {"y", [](int x) { return x + 1; }}
};

int x = 0;
int a = map1["a"](x); // 取出包装器并调用

bind 函数

bind 也是一个函数模板，位于 #include <functional> 中。它像一个函数包装器，接受一个可调用对象，生成一个新的可调用对象来'适应'原对象的参数列表。

主要作用：改变参数顺序 + 固定部分参数的值。

与普通缺省值的区别

普通缺省值只能给固定的参数指定默认值，而 bind 可以在运行时动态绑定参数。

普通函数用法

#include <functional>

double Plus(int a, int b, double rate) {
    return (a + b) * rate;
}

// 固定 rate 为 4.0，交换 a 和 b 的顺序
std::function<double(int, int)> Plus1 = std::bind(
    Plus, 
    std::placeholders::_2, 
    std::placeholders::_1, 
    4.0
);

// 调用：Plus1(9, 8) 等价于 Plus(8, 9, 4.0)

如果固定值在中间：

double Plus(int a, double rate, int b) {
    return (a + b) * rate;
}

std::function<double(int, int)> Plus2 = std::bind(
    Plus, 
    std::placeholders::_2, 
    4.0, 
    std::placeholders::_1
);
// Plus2(9, 8) -> 8 传给 a, 9 传给 b

类成员函数用法

• 静态函数：与普通函数类似，记得加上类域。
• 非静态函数：函数后面要跟上对象或对象的指针。

class SubType {
public:
    int sub(int a, int b) { return a - b; }
};

SubType st;

// 绑定对象指针
std::function<double(int, int)> Sub1 = std::bind(
    &SubType::sub, &st, 
    std::placeholders::_1, 
    std::placeholders::_2, 
    3
);

// 绑定对象值
std::function<double(int, int)> Sub2 = std::bind(
    &SubType::sub, st, 
    std::placeholders::_1, 
    std::placeholders::_2, 
    3
);

// 绑定匿名对象
std::function<double(int, int)> Sub3 = std::bind(
    &SubType::sub, SubType(), 
    std::placeholders::_1, 
    std::placeholders::_2, 
    3
);

注意：类里面的函数在外面用的时候必须要到类域里面去找才行。

练习题

关于范围 for 循环的理解，以下说法错误的是？

A. 范围 for 可以直接应用在数组上 B. 对于 STL 提供的所有容器，均可以使用范围 for 依次访问其元素 C. 使用范围 for 操作 stack，可以简化代码 D. 对于自定义类型，想要支持范围 for，必须提供 begin 和 end 迭代器 E. 范围 for 编译器最终是将其转化为迭代器来进行处理的

答案：C

解析：题目中提到的是容器，但是 stack 是容器适配器，不支持随机访问迭代器，因此不能直接使用范围 for 遍历。