C++ 之【C++11的简介】（可变参数模板、lambda表达式、function\bind包装器）

zl_dfq2025-09-16 9:34

目录

1.可变参数模板

[1.1 递归函数方式展开参数包](#1.1 递归函数方式展开参数包)

1.2逗号表达式展开参数包

[1.3 STL容器中的empalce相关接口函数](#1.3 STL容器中的empalce相关接口函数)

2.lambda表达式

2.1lambda表达式语法

2.2函数对象与lambda表达式

3.包装器

3.1function

3.2bind

1.可变参数模板

复制代码 
template <class ...Args>
 void ShowList(Args... args)
 {}

Args (名字可以随便取) 是一个模板参数包，args是一个函数形参参数包

声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。

1.1 递归函数方式展开参数包

复制代码 
// 递归终止函数
template <class T>
void ShowList(const T& t)
{
	cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
	cout << value << " ";
	ShowList(args...);
}

 int main()
 {
	 ShowList(1);//args中参数为0个
	 ShowList(1, 'A');//args中参数为1个
	 ShowList(1, 'A', std::string("sort"));//args中参数为2个
	 return 0;
 }

1.2逗号表达式展开参数包

复制代码 
template <class T>
void PrintArg(T t)
{
	cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}

 int main()
 {
	 ShowList(1);
	 ShowList(1, 'A');
	 ShowList(1, 'A', std::string("sort"));
	 return 0;
 }

在创建数组的过程中会先执行逗号表达式前面的部分printarg(args) 打印出参数，

也就是说在构造int数组的过程中就将参数包展开了，

这个数组的目的纯粹是为了在数组构造的过程展开参数包

复制代码 
struct Date
{
	int _year;
	int _month;
	int _day;

	Date(int year = 2025, int month = 9, int day = 15)
		:_year(year),_month(month),_day(day)
	{ }
};

template<class...Args>
Date* Create(Args&&... args)
{
	return new Date(std::forward<Args>(args)...);
}

int main()
{
	Date* p1 = Create();
	Date* p2 = Create(2025);
	Date* p3 = Create(2025, 9);
	Date* p4 = Create(2025, 9, 9);

	return 0;
}

Create函数支持万能引用与完美转发，且Date函数存在默认构造函数

所有后续调用Create函数

1.3 STL容器中的empalce相关接口函数

复制代码 
 template <class... Args>
 void emplace_back (Args&&... args);

emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象(参数包匹配)

那么在这里我们可以看到除了用法上，和push_back没什么太大的区别

复制代码 
int main()
{
	std::list< std::pair<int, char> > mylist;

	mylist.emplace_back(10, 'a');//参数包接收参数往下传
	mylist.emplace_back(20, 'b');
	mylist.emplace_back(make_pair(30, 'c'));
	mylist.push_back(make_pair(40, 'd'));
	mylist.push_back({ 50, 'e' });
	for (auto e : mylist)
		cout << e.first << ":" << e.second << endl;
	return 0;
}

下面我们试一下带有拷贝构造和移动构造的string

我们会发现其实差别也不到，emplace_back是直接构造了，

push_back是先构造，再移动构造，其实也还好。

复制代码 
int main()
{
	std::list< std::pair<int, string> > mylist;
	mylist.emplace_back(10, "sort");//参数包往下传，直接构造pair对象
	mylist.emplace_back(make_pair(20, "sort"));
	mylist.push_back(make_pair(30, "sort"));//先创建pair对象，再移动构造节点中的pair
	mylist.push_back({ 40, "sort" });
	return 0;
}

类似实现

复制代码 
template <typename... Args>
void emplace_back(Args&&... args) {
    if (size() >= capacity()) {
        // 可能触发内存重新分配（影响所有元素）
        reserve(std::max(size() * 2, 1));
    }
    // 在容器内存中直接构造对象（完美转发参数）
    new (data() + size()) T(std::forward<Args>(args)...);
    ++size_;
}

2.lambda表达式

2.1lambda表达式语法

lambda表达式书写格式：

[capture-list] (parameters) mutable -> return-type { statement }

[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来

判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda

函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以

连同()一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量

性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回

值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推

导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获

到的变量。

注意：

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为
空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

复制代码 
int main()
{
    // 最简单的lambda表达式, 该lambda表达式没有任何意义
    [] {};
    // 省略参数列表和返回值类型，返回值类型由编译器推导为int
    int a = 3, b = 4;
    [=] {return a + 3; };
    // 省略了返回值类型，无返回值类型
    auto fun1 = [&](int c) {b = a + c; };
    fun1(10);
        cout << a << " " << b << endl;
    // 各部分都很完善的lambda函数
    auto fun2 = [=, &b](int c)->int {return b += a + c; };
    cout << fun2(10) << endl;
    // 复制捕捉x
    int x = 10;
    auto add_x = [x](int a) mutable { x *= 2; return a + x; };
    cout << add_x(10) << endl;
    return 0;
}

lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量
2. 捕获列表说明
捕捉列表描述了上下文中哪些数据可以被lambda使用，以及使用的方式传值还是传引用 。
[var] ：表示值传递方式捕捉变量var
[=] ：表示值传递方式捕获所有父作用域中的变量(包括this)

[&var] ：表示引用传递捕捉变量var
[&] ：表示引用传递捕捉所有父作用域中的变量(包括this)
[this] ：表示值传递方式捕捉当前的this指针

注意：

a. 父作用域指包含lambda函数的语句块

Lambda 的父作用域包括：

局部变量：在 Lambda 定义之前声明的局部变量。

全局变量：在任何函数外部定义的变量。

静态变量：使用 static 定义的变量。

类成员（如果 Lambda 定义在成员函数内）：可以通过 this 捕获。

但不包括：

在 Lambda 定义之后声明的变量（因为它们在 Lambda 的作用域之外）。

局部变量的作用域仅限于它们所在的块（{}）。

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量

\&，a, this\]：值传递方式捕捉变量a和this，引用方式捕捉其他变量 c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。 比如：\[=, a\]：=已经以值传递方式捕捉了所有变量，捕捉a重复 d. **如果 Lambda 函数定义在全局作用域（即不在任何函数或代码块 `{}` 内部），那么它的捕获列表（Capture List）必须为空** e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者 非局部变量都会导致编译报错。 f. lambda表达式之间不能相互赋值，即使看起来类型相同

复制代码 
void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
	// 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
   //f1 = f2;    // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();

	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}

2.2函数对象与lambda表达式

复制代码 
class Rate
{
public:
	Rate(double rate)
		: _rate(rate)
	{}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	// 函数对象
	double rate = 0.49;
	Rate r1(rate);
	r1(10000, 2);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
	r2(10000, 2);
	return 0;
}

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()

3.包装器

3.1function

复制代码 
template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}
double f(double i)
{
	return i / 2;
}
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};
int main()
{
	// 函数名
	cout << useF(f, 11.11) << endl;
	// 函数对象
	cout << useF(Functor(), 11.11) << endl;
	// lamber表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
	return 0;
}

通过上面的程序验证，我们会发现useF函数模板实例化了三份
包装器可以很好的解决上面的问题

std::function

作用：通用函数包装器，可以存储可调用对象（函数、Lambda、函数对象、成员函数等）

复制代码 
#include <functional>
#include <iostream>

// 示例函数
int add(int a, int b) { return a + b; }

int main() {
    // 1. 包装普通函数
    std::function<int(int, int)> func1 = add;
    std::cout << func1(3, 4) << std::endl;  // 输出 7

    // 2. 包装 Lambda 表达式
    std::function<int(int, int)> func2 = [](int a, int b) { return a * b; };
    std::cout << func2(3, 4) << std::endl;  // 输出 12

    // 3. 包装函数对象（仿函数）
    struct Divide {
        int operator()(int a, int b) const { return a / b; }
    };
    std::function<int(int, int)> func3 = Divide();
    std::cout << func3(10, 2) << std::endl;  // 输出 5
}

function<返回值(参数列表)>

3.2bind

std::bind

作用：部分应用（Partial Application）或调整参数顺序，生成一个新的可调用对象。

特点：

可以绑定固定参数，使用占位符（_1, _2）调整参数顺序。通常与 std::function 结合使用。

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来"适应"原对象的参数列表。

一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M 可以大于N，但这么做没什么意义）参数的新函数。

同时，使用std::bind函数还可以实现参数顺序调整等操作

语法

复制代码 
auto newCallable = std::bind(originalCallable, arg1, arg2, ...);

originalCallable：原始的可调用对象（函数、函数指针、成员函数、函数对象等）。

arg1, arg2, ...：绑定参数，可以是：

具体值（绑定后固定不变）。

占位符（std::placeholders::_1, _2, ...），表示调用时传入的参数

绑定普通函数

绑定部分参数
复制代码 
#include <iostream>
#include <functional> // 包含 std::bind

void printSum(int a, int b) {
    std::cout << a + b << std::endl;
}

int main() {
    // 绑定第一个参数为 10，第二个参数待定（用 _1 表示）
    auto f = std::bind(printSum, 10, std::placeholders::_1);

    f(20); // 相当于 printSum(10, 20)，输出 30
    f(30); // 相当于 printSum(10, 30)，输出 40

    return 0;
}

std::bind(printSum, 10, _1) 生成一个新的函数对象 f，其中：

第一个参数固定为 10。

第二个参数由调用 f 时的第一个参数（_1）决定。

调整参数顺序
复制代码 
void printValues(int a, int b, int c) {
    std::cout << a << ", " << b << ", " << c << std::endl;
}

int main() {
    // 调整参数顺序：_1, _3, _2
    auto f = std::bind(printValues, std::placeholders::_1, std::placeholders::_3, std::placeholders::_2);

    f(1, 2, 3); // 相当于 printValues(1, 3, 2)，输出 "1, 3, 2"

    return 0;
}

_1 表示调用 f 时的第一个参数。

_3 表示调用 f 时的第三个参数。

_2 表示调用 f 时的第二个参数。

绑定成员函数

绑定成员函数时，第一个参数必须是对象实例（this 或对象引用/指针）

复制代码 
#include <iostream>
#include <functional>

class Printer {
public:
    void print(int x) {
        std::cout << x << std::endl;
    }
};

int main() {
    Printer p;

    // 绑定成员函数，第一个参数是对象（可以用 & 或 std::ref）
    auto f1 = std::bind(&Printer::print, &p, std::placeholders::_1);
    f1(10); // 相当于 p.print(10)，输出 10

    // 也可以用 std::ref 避免拷贝
    auto f2 = std::bind(&Printer::print, std::ref(p), std::placeholders::_1);
    f2(20); // 相当于 p.print(20)，输出 20

    return 0;
}

&Printer::print 是成员函数指针。

&p 或 std::ref(p) 是对象实例（如果用 std::ref，可以避免拷贝）

这是因为成员函数中默认有一个this指针参数

绑定仿函数

复制代码 
#include <iostream>
#include <functional>

struct Multiplier {
    int operator()(int a, int b) {
        return a * b;
    }
};

int main() {
    Multiplier multiplier;

    // 绑定第一个参数为 5，第二个参数待定（_1）
    auto f = std::bind(multiplier, 5, std::placeholders::_1);

    std::cout << f(10) << std::endl; // 5 * 10 = 50
    std::cout << f(20) << std::endl; // 5 * 20 = 100

    return 0;
}
相关推荐
每天回答3个问题2 小时前
UE5C++编译遇到MSB3073
开发语言·c++·ue5
凯子坚持 c2 小时前
精通 Redis list：使用 redis-plus-plus 的现代 C++ 实践深度解析
c++·redis·list
JCBP_3 小时前
QT（4）
开发语言·汇编·c++·qt·算法
会开花的二叉树3 小时前
继承与组合：C++面向对象的核心
java·开发语言·c++
潮汐退涨月冷风霜4 小时前
数字图像处理(1）OpenCV C++ & Opencv Python显示图像和视频
c++·python·opencv
第七序章5 小时前
【C＋＋STL】list的详细用法和底层实现
c语言·c++·自然语言处理·list
逆小舟7 小时前
【Linux】人事档案——用户及组管理
linux·c++
风中的微尘12 小时前
39.网络流入门
开发语言·网络·c++·算法
混分巨兽龙某某12 小时前
基于Qt Creator的Serial Port串口调试助手项目（代码开源）
c++·qt creator·串口助手·serial port
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南03UV安装并设置国内源04A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程0546个Nano-banana 精选提示词，持续更新中06KGG转MP3工具|非KGM文件|解密音频07解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题08conda中设置镜像地址（附所有可换的地址）09智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践10Claude Code 平替：OpenAI发布 Codex CLI ，GPT-5 国内直接使用