- C++(3)
- functor 仿函数
- Lambda
- 写法: Lambda:[]{}
- 写法 Lambda:{}
- 写法 Lambda:->{}
- 闭包[]与 mutable
- []捕获规则
- for each
- sort()/list::sort
- QT 中 signal 和 slot 机制
- lambda 与 仿函数
C++(3)
functor 仿函数
重载了 operator()的类的对象，在使用中，语法类型于函数。故称其为仿函数。
此种用法优于常见的函数回调。
相对于函数，仿函数，可以拥用初始状态，一般通过 class 定义私有成员，并在声
明对象的时候，进行初始化。
# if 1
//todo 仿函数
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Compare {
public:
Compare(bool flag=false):flag(flag) {}
int operator()(int a, int b) {
if (flag) {
return a < b;
} else {
return a > b;
}
}
protected:
bool flag;
};
int main() {
vector<int> v = { 12, 332, 35, 9, 5 };
sort(v.begin(), v.end(), Compare(true));
for (auto i : v) {
cout << i << " ";
}
return 0;
}
# endif
Lambda
简短函数，就地书写，调用，即 Lambda 存在的意义，常用于取代作回调用的简
短函数指针与仿函数。
就地书写，因只有函数体，即无函数名，也称匿名函数。
格式:
[capturelist] (parameterlist) mutable ->return type { function body }
[捕获列表](参数列表) -> 返回类型 { 函数体 }
capturelist
捕获列表。捕获列表，总是出现在 lambda 函数的开始处。事实上[]是 lambda 的
引用符。换句话说，编译器根据引出符判断接下来的代码是否是 lamba 函数。
parameterlist
参数列表。与普通函数的参数列表一致。如果不需要传递参数，可以连同()一起省
略。
mutable
默认情况下，lambda 函数总是一个 const 函数，mutable 可以取消其常量性,所
谓的常量性是指不可修改 capturelist 中的东西。在使用该修饰符时，参数列表不可以
省略（即使参数为空）
->return type
返回类型。用于追踪返回类型形式声明函数的返回类型。出于方便，不需要返回值
的时候可以连同->一起省略。此外返回类型明确的情况下，也可以省略该部分。编译
器可以自行推导。
{ function body }
函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获
的变量。
//todo Lambda
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
vector<int> v = { 12, 332, 35, 9, 5 };
sort(v.begin(), v.end(), [](int a, int b) {return a < b;} );
for (auto i : v) {
cout << i << " ";
}
return 0;
}
写法: Lambda:[]{}
//todo Lambda:[](){}
#include <iostream>
using namespace std;
int main() {
auto F=[]{return 1+2;};
cout<<F()<<endl;
cout<<[]{return 1+2;}()<<endl;
return 0;
}
写法 Lambda:{}
//todo Lambda:[](){}
#include <iostream>
using namespace std;
int main() {
auto F=[](int a, int b){return a+b;};
cout<<F(1,2)<<endl;
cout<<[](int a=1, int b=2){return a+b;}()<<endl;
return 0;
}
写法 Lambda:->{}
#include <iostream>
using namespace std;
int main() {
auto F=[](int a, int b)->int{return a+b;};
cout<<F(1,2)<<endl;
cout<<[](int a=1, int b=2)->int{return a+b;}()<<endl;
return 0;
}
闭包[]与 mutable
闭包
closure 是一个函数和它所引用的非本地变量的上下文环境的集合。
从定义我们可以得知，closure 可以访问在它定义范围之外的变量，也即 non-local vriables（非局部变量）。
关于 closure 的最重要的应用就是回调函数lambda 函数能够捕获 lambda 函数外的具有自动存储时期的变量。
函数体与这些变量的集合合起来叫闭包。
闭包的概念在 lambda 中通过[]来体现出来。
& 引用
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
int x = 10; int y = 100;
cout<<"main:"<<x<<y<<endl;//main:10100
auto foo = [&]() mutable {
x = 20;
y = 200;
cout<<"lambda:"<<x<<y<<endl; //lambda:20200
};
foo();
cout<<"main:"<<x<<y<<endl; //main:20200
return 0;
}
输出:
main:10100
lambda:20200
main:20200
= 值传递复制产生副本 const --> mutable
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
int x = 10; int y = 100;
cout<<"main:"<<x<<y<<endl;//main:10100
auto foo = [=]() mutable {
x = 20;
y = 200;
cout<<"lambda:"<<x<<y<<endl; //lambda:20200
};
foo();
cout<<"main:"<<x<<y<<endl; //main:10100
return 0;
}
输出:
main:10100
lambda:20200
main:10100
&x, y 引用传递
# if 1
//todo 闭包
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
int x = 10; int y = 100;
cout<<"main:"<<x<<y<<endl;//main:10100
auto foo = [&x, y]() mutable {
x = 20;
y = 200;
cout<<"lambda:"<<x<<y<<endl; //lambda:20200
};
foo();
cout<<"main:"<<x<<y<<endl; //main:20100
return 0;
}
# endif
main:10100
lambda:20200
main:20100
[]捕获规则
| 形式 | 语义 |
|---|---|
| [] | 不截取任何变量 |
| [=] | 截取外部作用域中所有变量，并按值传递在函数体中使用。 |
| [&] | 截取外部作用域中所有变量，并作为引用传递在函数体中使用。 |
| [x,y] | 捕获 x,y 变量，按值传递 |
| [x,&y] | 仅 x 按值传递，y 按引用传递在函数体中使用。 |
| [=, &foo] | 截取外部作用域中所有变量，并值传递在函数体中使用，但是对 foo变量使用引用传递。 |
| [&, =foo] | 截取外部作用域中所有变量，在函数体中作引用传递使用，但是对 foo变量作值传递。=foo -> foo |
上述，中涉及到值传递要发生拷贝行为，而引用传递则不会发生拷贝行为。捕获列
表中不允许重复。
for each
for_each 是 C++ 标准库中的一个算法，用于遍历容器并对每个元素执行指定的操作。它有以下几个优点：
简洁性：
使用 for_each 可以使代码更加简洁和易读。相比于传统的 for 循环，for_each 将遍历和操作分离，使得逻辑更加清晰。
灵活性：
for_each 可以接受任何可调用对象（如函数、函数指针、lambda 表达式、仿函数等），这使得它可以灵活地应用于各种不同的操作。
通用性：
for_each 是标准库的一部分，适用于任何支持迭代器的容器（如 vector、list、deque 等），具有很好的通用性。
避免手动管理迭代器：
使用 for_each 可以避免手动管理迭代器的复杂性，减少出错的可能性
支持并行化：
一些现代 C++ 标准库的实现（如 Intel TBB 和 Microsoft PPL）提供了并行版本的 for_each，可以利用多核处理器提高性能。
// for each
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
// 创建一个包含整数的向量，并初始化
vector<int> v = { 12, 332, 35, 9, 5 };
// 使用for_each算法遍历向量v
// v.begin()返回指向向量第一个元素的迭代器
// v.end()返回指向向量最后一个元素之后的迭代器
// lambda表达式用于对每个元素执行操作
for_each(
v.begin(), // 开始位置
v.end(), // 结束位置
[](int& a) { // lambda表达式，接受一个整数引用a
cout << a << " "; // 输出当前元素a，
}
);
return 0;
}
sort()/list::sort
sort 函数在 C++ 标准库中是一个非常强大且灵活的工具，它具有以下几个优点：
通用性：
sort 可以用于几乎所有支持随机访问迭代器的容器，如 std::vector、std::deque 等。这使得它在处理不同类型的数据结构时非常通用。
高效性：
sort 通常实现为一种高效的排序算法，最常见的是快速排序（QuickSort），其平均时间复杂度为 。在实际应用中，sort 的性能通常非常出色。
灵活性：
sort 允许用户提供自定义的比较函数或 lambda 表达式，这使得它可以适应各种不同的排序需求。无论是简单的升序/降序排序，还是复杂的自定义排序规则，sort 都能轻松应对。
稳定性：
在 C++11 及以后的版本中，标准库提供了 std::stable_sort，它可以保证相等元素的相对顺序不变。这在某些需要保持元素原有顺序的场景中非常有用。
易于使用：
sort 的接口非常简单直观，只需要提供待排序范围的起始和结束迭代器，以及可选的比较函数。这使得它在实际编程中非常易于使用。
与标准库其他算法兼容：
sort 可以与其他标准库算法（如 std::for_each、std::transform 等）无缝配合使用，进一步提高代码的复用性和可维护性。
#include <iostream>
#include <vector>
#include <list>
#include <stdlib.h>
#include <time.h>
#include <algorithm>
#include <functional>
using namespace std;
// 自定义比较函数，用于升序排序
bool Compare(int i, int j)
{
return i < j;
}
int main(int argc, char *argv[])
{
// 定义一个整数向量
vector<int> vi;
// 初始化随机数生成器
srand(time(NULL));
// 向向量中添加10个随机数，范围在0到99之间
for (int i = 0; i < 10; i++)
{
vi.push_back(rand() % 100);
}
// 使用自定义比较函数对向量进行排序
sort(vi.begin(), vi.end(), Compare);
// 使用lambda表达式对向量进行排序
sort(vi.begin(), vi.end(), [](int x, int y) {
return x < y;
});
// 使用for_each算法和lambda表达式遍历并输出向量中的每个元素
for_each(vi.begin(), vi.end(), [](int i) {
cout << i << endl;
});
return 0;
}
QT 中 signal 和 slot 机制
QObject::connect 是 Qt 框架中用于连接信号和槽（或函数）的函数。
这个特定的重载版本允许你将一个信号连接到一个函数对象（Functor）。
QMetaObject::Connection QObject::connect(
const QObject *sender, // 发送信号的对象
PointerToMemberFunction signal, // 信号的成员函数指针
Functor functor // 接收信号的函数对象
);
参数说明：
sender：指向发送信号的对象的指针。
signal：指向发送对象的信号成员函数的指针。信号通常以 SIGNAL() 宏定义。
functor：接收信号的函数对象。这个函数对象可以是 lambda 表达式、函数指针或 std::function。
返回值：
返回一个 QMetaObject::Connection 对象，该对象可以用于断开连接。
示例:
#include "mainwin.h"
#include "ui_mainwin.h"
// mainwin 类的构造函数
mainwin::mainwin(QWidget *parent) :
QWidget(parent), // 调用基类 QWidget 的构造函数，并传递父对象指针
ui(new Ui::mainwin) // 创建 Ui::mainwin 类的实例
{
ui->setupUi(this); // 设置 UI，将 UI 元素与当前窗口关联
// 设置窗口的几何位置和大小
this->setGeometry(600, 400, 400, 200);
// 创建一个 QDial 控件，并将其父对象设置为当前窗口
_dial = new QDial(this);
// 设置 QDial 的范围为 0 到 100
_dial->setRange(0, 100);
// 设置 QDial 的几何位置和大小
_dial->setGeometry(50, 50, 100, 100);
// 设置 QDial 自动填充背景
_dial->setAutoFillBackground(true);
// 创建一个 QProgressBar 控件，并将其父对象设置为当前窗口
_pBar = new QProgressBar(this);
// 设置 QProgressBar 的几何位置和大小
_pBar->setGeometry(250, 40, 20, 120);
// 设置 QProgressBar 的最小值为 0
_pBar->setMinimum(0);
// 设置 QProgressBar 的最大值为 100
_pBar->setMaximum(100);
// 设置 QProgressBar 的方向为垂直
_pBar->setOrientation(Qt::Vertical);
// 连接 QDial 的 valueChanged 信号到一个 lambda 表达式
connect(_dial, &QDial::valueChanged, [&]() {
// 在 lambda 表达式中，设置 QProgressBar 的值为 QDial 的当前值
_pBar->setValue(_dial->value());
});
}
mainwin::~mainwin() {
delete ui;
}
lambda 与 仿函数
lambda 本质就是匿名的仿函数。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
