❀C++11
前言：在C++编程语言的悠久历史中，每一次标准的更新都带来了革命性的变化，推动了编程范式和性能优化的新边界。C++11标准，作为这一漫长演进过程中的一个重要里程碑，不仅巩固了C++作为高性能系统级编程语言的地位，还引入了众多现代编程特性，极大地丰富了C++的表达力和易用性。其中，lambda表达式和std::function无疑是这些新特性中最引人注目且影响深远的两个
本篇旨在深入探讨C++11中的lambda表达式和std::function，通过理论讲解、示例演示和实战应用，帮助读者全面理解并掌握这两个重要特性
让我们一起踏上学习的旅程，探索它带来的无尽可能！
📒1. 可变参数模板
C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以这块还是比较晦涩的
可变参数的函数模板：
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点
递归函数方式展开参数包：
void _ShowList()
{
cout << endl;
}
template <class T, class ...Args>
void _ShowList(const T& value, Args... args)
{
cout << value << " ";
_ShowList(args...);
}
template <class ...Args>
void ShowList(Args... args)
{
_ShowList(args...);
}
int main()
{
ShowList(1);
ShowList(1,2);
ShowList(1,2,3);
return 0;
}
获取参数包的大小：
void ShowList(Args... args)
{
// 这里有些特殊，我们需要将省略号写在sizeof后面
cout << sizeof...(args) << endl;
}
📚2. lambda表达式
在C++11之前对一个数据集合中的元素进行排序
std::sort
#include <algorithm>
int main()
{
int array[] = { 4,1,8,5,3,7,0,9,2,6 };
// 默认按照小于比较，排出来结果是升序
std::sort(array, array + sizeof(array) / sizeof(array[0]));
// 如果需要降序，需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
return 0;
}
仿函数
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
struct ComparePriceLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
for (size_t i = 0; i < v.size(); i++)
{
cout << v[i]._name << ":" << v[i]._price << ":" << v[i]._evaluate << endl;
}
}
随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，
都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，
这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式
🌞lambda表达式
对一个数据集合中的元素进行排序
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price > g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate < g2._evaluate; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate > g2._evaluate; });
for (size_t i = 0; i < v.size(); i++)
{
cout << v[i]._name << ":" << v[i]._price << ":" << v[i]._evaluate << endl;
}
}
int main()
{
auto f1 = []() {};
cout << typeid(f1).name() << endl;
return 0;
}
🌙lambda表达式语法
表达式各部分说明
| 部位 | 说明 |
|---|---|
| [capture-list] | 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。 |
| (parameters) | 参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略 |
| mutable | 默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。 |
| ->returntype | 返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。 |
| {statement} | 函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量 |
int main()
{
// 省略了返回值类型，无返回值类型
auto f2 = [](int* x, int* y)
{
cout << &x << " " << &y << endl;
int tmp = *x;
*x = *y;
*y = tmp;
};
}
捕获列表说明
| 符号 | 意义 |
|---|---|
| [var] | 表示值传递方式捕捉变量var |
| [=] | 表示值传递方式捕获所有父作用域中的变量(包括this) |
| [&var] | 表示引用传递捕捉变量var |
| [&] | 表示引用传递捕捉所有父作用域中的变量(包括this) |
| [this] | 表示值传递方式捕捉当前的this指针 |
int main()
{
int a = 7; int b = 9;
// 不加mutable会报错，因为默认情况Lambda是const函数
auto f3 = [&a, &b]()mutable
{
cout << &a << " " << &b << endl;
int tmp = a;
a = b;
b = tmp;
};
}
注意：
在使用lambda时，其实就是相当于调用了一个函数
⭐函数对象与lambda表达式
class Pxt
{
public:
Pxt(double money)
: _money(money)
{}
double operator()(int day)
{
return _money * day;
}
private:
double _money;
};
int main()
{
double money = 100;
Pxt p1(money);
cout << p1(10) << endl;
auto p2 = [=](double money, int day)->double {return money * day; };
cout << p2(100, 10) << endl;
return 0;
}
📝3. 包装器
🎩function包装器
template<class F, class T>
T useF(F f, T x)
{
return f(x);
}
double f(double i)
{
return 1;
}
struct Functor
{
double operator()(double d)
{
return 1;
}
};
int main()
{
// 函数名
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lamber表达式
cout << useF([](double d)->double { return d; }, 11.11) << endl;
return 0;
}
template <class Ret, class... Args>
class function<Ret(Args...)>;
//模板参数说明：
//Ret: 被调用函数的返回类型
//Args…：被调用函数的形参
lambda表达式
function<int(int, int)> func1 = [](const int a, const int b) { return a+b; };
🎈bind
// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
示例：
int Plus(int a, int b)
{
return a + b;
}
class Sub
{
public:
int sub(int a, int b)
{
return a - b;
}
};
int main()
{
//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
function<int(int, int)> func1 = bind(Plus, placeholders::_1,
placeholders::_2);
//func2的类型为 function<void(int, int, int)> 与func1类型一样
//表示绑定函数 plus 的第一，二为： 1， 2
auto func2 = bind(Plus, 1, 2);
cout << func1(1, 2) << endl;
cout << func2() << endl;
Sub s;
// 绑定成员函数
function<int(int, int)> func3 = bind(&Sub::sub, s,
placeholders::_1, placeholders::_2);
// 参数调换顺序
function<int(int, int)> func4 = bind(&Sub::sub, s,
placeholders::_2, placeholders::_1);
cout << func3(1, 2) << endl;
cout << func4(1, 2) << endl;
return 0;
}
📖4. 总结
在深入探讨C++11引入的lambda表达式与包装器（也称为闭包）的旅程即将结束时，我们不禁要为这一强大特性的加入而赞叹。Lambda表达式不仅极大地丰富了C++的表达能力，还让编程变得更加灵活、直观和高效。它们如同编程语言中的魔法，允许开发者在需要函数或函数对象的地方，以极其简洁的方式定义并立即使用匿名函数
C++11中的lambda表达式和包装器是C++发展史上的一个重要里程碑。它们不仅为C++语言注入了新的活力，也为广大开发者提供了更加高效、灵活的编程手段。随着C++的不断演进和发展，我们有理由相信，lambda表达式将会在更多的场景中得到应用
希望本文能够为你提供有益的参考和启示，让我们一起在编程的道路上不断前行！
谢谢大家支持本篇到这里就结束了，祝大家天天开心！
