[C++语法基础与基本概念] std::function与可调用对象

news/2025/2/21 4:26:30/

std::function与可调用对象

  • 函数指针
  • lambda表达式
  • std::function与std::bind
  • 仿函数
  • 总结
    • std::thread与可调用对象
    • std::async与可调用对象
    • 回调函数

可调用对象是指那些像函数一样可以直接被调用的对象,他们广泛用于C++的算法,回调,事件处理等机制。

函数指针

函数指针是最简单的一种可调用对象

我们大家应该都用过函数名来作为函数的地址,但是函数名称其实与函数的地址是有一些细微的差别的

void printHello() {std::cout << "Hello, World!" << std::endl;
}

以上面的函数为例,函数的名称是printHello, 但是它的类型其实是void() , 而不是void(*)(),但是它可以被隐式的转化成void( * ),

void (*ptr)() = printHello;

在上面这行代码中,printHello会被隐式转化为void( * )(), 这就跟char [] 能被隐式的转化为char *很类似

如下代码也能完成上述转化,但是是显示的取函数地址

void (*ptr)() = &printHello

显示利用&运算符取地址

言归正传,在得到函数指针之后,我们就可以直接通过函数指针调用函数,并且可以将其作为一些函数的参数

例如:

bool cmp( int a, int b)
{return a < b;
}std::vector<int> vec = {2,1,4,3,7,6};
std::sort(vec.begin(),vec.end(),cmp);

上述例子就会将容器vec中的元素从小到大进行一个排序了。

lambda表达式

lambda是C++11引入的一种匿名函数对象,提供了一种简单的方式用来定义内联函数,它的标准格式如下:

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

[capture-list] 捕获列表,捕获的变量可以在lambda表达式的函数体内使用
(parameters) 参数列表,与函数的参数列表一致
-> return-type 返回值,如果不写,lambda表达式会自动推导返回值
{body} 函数体

既然返回值可以省略,lambda表达式最常见的格式就是

[](){}

其中

[&x] 表示用引用的方式捕获变量x
[x] 表示用值捕获的方式捕获变量x
[=] 按值捕获的方式捕获作用域内所有变量
[&] 按引用捕获的方式捕获作用域内所有变量
[a, &b] 按值捕获a, 按引用捕获b

lambda表达式最简单的使用方式:

auto lambda = [](){std::cout << "Hello World" << std::endl;  
};
lambda();
int x = 5;
auto lambda = [x](int a){return x + a;
};
lambda(6);

如上图两个例子所示,lambda表达式可以就像普通函数那样被调用

lambda表达式的类型

auto lambda = [](){std::cout << "Hello World" << std::endl;  
};

你知道此时auto是什么类型吗?

编译器会为每一个lambda表达式,生成如下面所示的一个类:

class __lambda_1 {
public:void operator()() const {std::cout << "Hello, Lambda!" << std::endl;}
};

这个类是使用了operator重载了()运算符的一个类,听起来跟隐函数非常像,此时auto的类型就是 __lambda_1

同样,lambda表达式也可以带入到各种以可调用对象为参数的函数之中

auto lambda [](int x,int y){return x < y;
};std::vector<int> vec = {2,3,1,7,6,5};
std::sort(vec.begin(),vec.end(), lambda);

std::function与std::bind

std::funtion也是一个可调用对象,它本质上叫做泛型函数包装器,可以用来包装任何的可调用对象,只要这个可调用对象的调用签名与自己匹配即可。 也可以用来包装另一个std::funtion,因为function也是一个可调用对象

什么是调用签名?

std::function<int(int,int)> func ;

上面定义了一个调用签名为 int (int,int)的function对象,表示这个function只能用来包装返回值为int,参数为(int,int)的可调用对象

绑定普通函数-无参数

void printHello() {std::cout << "Hello, World!" << std::endl;
}std::function<void()> func = printHello;
func();

绑定lambda表达式

auto lambda = [](){std::cout << "Hello World" << std::endl;  
};
std::function<void()> func = lambda;
func();

绑定仿函数

class PrintFunctor {
public:void operator()() const {std::cout << "Hello from functor!" << std::endl;}
};PrintFunctor functor;
std::function<void()> func = functor;
func();
-----------------------------------------------------
int add(int a,int b)
{return a + b;
}class PrintFunctor {
public:int operator()(int x) const {return add(x,2);}
};
PrintFunctor functor;
std::function<int(int)> func = functor;
func(1);

绑定另一个function

void printHello() {std::cout << "Hello, World!" << std::endl;
}
std::function<void()> func1 = printHello;
std::function<void()> func2 = func1;

绑定普通函数-带参数

int add(int a,int b)
{return a + b;
}std::function<int(int,int)> func = add;
int res = func(1,2);

以上是一些实用std::function的最简单的例子,但是function还远不止于此,如果我们想让绑定更加灵活呢?例如,我们想绑定上面的add函数,但是其中一个参数是已经确定的,如何绑定呢? 这时候就需要用到std::bind

std::bind是用来生成std::function的一个函数,能让std::function的包装更加灵活, 他可以将所有的可调用对象包装成std::function

std::bind绑定普通函数

int add(int a,int b)
{return a < b ;
}
--------------------------------------------------------固定参数绑定
std::function<int()> func =  std::bind(add,1,2);
func(); //调用
--------------------------------------------------------不定参数绑定
std::function<int(int)> func = std::bind(add,1,std::placeholders::_1);
func(2); //调用std::function<int(int,int)> func = std::bind(add,std::placeholders::_1,std::placeholders::_2);
func(1,2);//调用

其中

std::placeholders::_1

表示参数,_1后缀表示第一个不定参数,如果想绑定多个不定参数,只需要让后缀继续加就行

std::bind绑定类成员函数

class MyClass {
public:int add(int x, int y) {return  x  + y;}
};MyClass myclass;
std::function<int(int,int)> func = std::bind(&MyClass:add,&myclass,add,std::placeholders::_1,std::placeholders::_2);
func(1,2); //调用

绑定lambda表达式

std::function<int(int,int)> func =  std::bind([](int x,int y){return x + y;},std::placeholders::_1,std::placeholders::_2);func(1,2); //调用

绑定std::function(套娃)

int add(int a,int b)
{return a + b ;
}
std::function<int(int,int)> func = std::bind(add,std::placeholders::_1,std::placeholders::_2);
std::function<int(int)> func1 =  std::bind(func1,1,std::placeholders::_1);
func1(2);

绑定仿函数

class ADDFunctor { //
public:int operator()(int x) const {return add(x,2);}
};
ADDFunctor functor;
std::function<int(int)> func = std::bind(functor,std::placeholders::_1);
func(1);

上面介绍了这么多,其实都一样,只要是可调用对象,绑定的方式都相同,只有类成员函数的绑定方式要特殊一些,需要指定对象。

同样,std::function也可以带入到std::sort中作为比较子:

std::function<iint(int,int)> func =  std::bind([](int x,int y){return x < y;},std::placeholders::_1,std::placeholders::_2);std::vector<int> vec = {5,2,3,7,1,4};std::sort(vec.begin(),vec.end(),func);---------------------------------------------std::sort(vec.begin(),vec.end(),std::bind([](int x,int y){return x < y;
},std::placeholders::_1,std::placeholders::_2)); //lambda表达式比较多余,这里直接用lambda表达式就行
//仅用来展示语法

在使用std::bind绑定时,经常要用到std::placeholders::_1,这就会导致单行代码过于长,为了处理好看的问题,经常使用宏定义的方式处理。

#define PHS std::placeholders// 绑定普通函数(当然也可以用于绑定其他可调用对象)
#define BIND_FUNC_0(_f) std::bind(_f)
#define BIND_FUNC_1(_f) std::bind(_f, PHS::_1)
#define BIND_FUNC_2(_f) std::bind(_f, PHS::_2)//绑定类成员函数
#define BIND_CLASS_FUNC_0(_c, _f, _p) std::bind(&_c::_f, _p)
#define BIND_CLASS_FUNC_1(_c, _f, _p) std::bind(&_c::_f, _p, PHS::_1)
#define BIND_CLASS_FUNC_2(_c, _f, _p) std::bind(&_c::_f, _p, PHS::_1,PHS::_2)

BIND_FUNC_0 表示绑定一个参数为0的可调用对象 _f表示函数名称
BIND_FUNC_1 表示绑定一个参数为1的可调用对象,以此类推

BIND_CLASS_FUNC_0 表示绑定一个参数为0的类成员函数_c表示类名,_f表示函数名,_p表示对象名称

仿函数

仿函数就是使用 operator重载了()运算符的类

class PrintFunctor {
public:int operator()(int x) const {return add(x,2);}
};
PrintFunctor functor;
functor(1);

一个类在重载了()运算符之后,就可以像函数那样被直接调用,但是它本质上又不是函数,所以吧叫做仿函数

class Functor {
public:int operator()(int x, int y) const {return x < y;}
};
Functor functor;
std::vector<int> vec = {5,2,3,7,1,4};
std::sort(vec.begin(),vec.end(), functor);

总结

除了上述std::sort的例子以外,还有一些用到可调用对象的函数

std::thread与可调用对象

普通函数

void Run(int x, int y, int z)
{.......
}std::thread t(Run,1,2,3);

类成员函数

class Myclass{public:void Run(int x,int y,int z){..........}
};
MyClass myclass;
std::thread t(&Myclass::Run,&myclass,1,2,3);

lambda表达式,std::function, 仿函数绑定方式也都和普通函数一样

auto lambda = [](int x,int y,int z){};
std::thread t(lambda,1,2,3);
----------------------------------------------
std::function<void(int,int,int)> func = std::bind(lambda, std::placeholders::_1,std::placeholders::_2, std::placeholders::_3);
std::thread t(func,1,2,3);
----------------------------------------------
class Myclass{public:void Run(int x,int y, int z){.............}
};
MyClass myclass;
std::thread t(myclass,1,2,3);

std::async与可调用对象

绑定std::function(其余就不展示了,因为都一样)

void Run(int x)
{.............
}
std::function<void(int)> func =  std::bind(Run,std::placeholders::_1);
std::async(std::launch::async, func,10); //开启一个异步任务

绑定类成员函数

class Myclass{public:void Run(int x,int y,int z){..........}
};
MyClass myclass;
std::async(std::launch::async,&Myclass::Run,&myclass,1,2,3);

回调函数

除了上面的例子之外,可调用对象还经常作为回调函数使用

什么是回调函数?

回调函数就是将一个可调用对象,通过函数或以其它方式传递过去并存储起来,然后在合适的时机被调用,通常是在某些事件发生之后被调用,例如在网络通信中,收到消息事件,如收到其他套接字发送来的消息,也或是在MQ,RPC通信时收到消息时被调用。

下面举一个简单的例子:

class Base
{
public: virtual void Notify(){};
};
class Base1
{public:virtual void SetFunc(std::function<void()> func){};
};
class Derived:pulibc Base, pulibc Base1
{public:Derive(){};void Notify(); //通常是某个事件的触发函数,例如收到某些信息时触发,读到某些数据时被调用触发void SetFunc(std::function<void()> func);//设置std::functionprivate:std::function<void()> func_;}
void Derived::Notify()
{// ..........// 对接受/读取的数据进行处理 .......//执行回调函数if(func_){func_();}
}void Derived::SetFunc(std::function<void()> func)
{func_ =  func;
}
Base1* base1 = new Derived();void PrintReceive()
{std::cout << "receive data!"<< std::endl;
}
std::function<void()> func = PrintReceive;base1->SetFunc(func);
Base* base = base1;//base指针也可能被传递给其他对象,在其他对象内部使用,当收到消息时,base指针的Notify函数被调用
//在Notify函数中触发了我们的回调函数,实现了当收到数据时,打印收到数据的日志。

http://www.ppmy.cn/news/1573797.html

相关文章

Linux日志系统

Linux日志系统 日志与日志系统介绍 计算机中的日志是记录系统和软件运行中发生事件的文件&#xff0c;主要作用是监控运行状态、记录异常信息&#xff0c;帮助快速定位问题并支持程序员进行问题修复。它是系统维护、故障排查和安全管理的重要工具 一般情况下&#xff0c;日志…

Tomcat的升级

Tomcat 是一个开源的 Java Servlet 容器&#xff0c;用于部署 Java Servlet 和 JavaServer Pages&#xff08;JSP&#xff09;。随着新版本的发布&#xff0c;Tomcat 通常会带来性能改进、安全增强、新特性和对最新 Java 版本的更好支持。升级 Tomcat 服务器通常涉及到以下几个…

计算机三级网络技术知识汇总【3】

第三章 IP地址规划设计技术 1. IP地址的概念 1.1 IP 地址分类 1.1.1 IP 地址的概念 IP 地址是网络号与主机号组成的32位二进制数。IP 地址通常用“点分十进制”表示成 (x.x.x.x) 的形式&#xff0c;其中&#xff0c;x.x.x.x 都是 0-255 之间的十进制整数。 例如&#xff1…

P3052 [USACO12MAR] Cows in a Skyscraper G

网址如下&#xff1a; P3052 [USACO12MAR] Cows in a Skyscraper G - 洛谷 &#xff08;题意翻译中的wi改成ci&#xff09; 好久没写博客了&#xff0c;寒假加入校队&#xff0c;高强度刷题&#xff0c;感觉懒得写&#xff0c;寒假前倒是写了一个关于虚拟机共用宿主机的VPN的博…

kamailio中的PV,PV Headers,App Lua,Dialog,UUID,Dianplan等模块的讲解

课程总结 今天的课程围绕 Kamailio模块 和 SIP服务器类型 展开&#xff0c;详细讲解了多个核心模块的功能、参数和使用方法&#xff0c;并深入探讨了SIP中B2BUA和Proxy Server的区别与应用场景。以下是今天课程的主要内容总结&#xff1a; 今日主题 Kamailio模块与SIP服务器类…

echarts柱状图属性

echarts柱状图属性 legend 组件的 itemGap 属性可以用来设置图例项之间的间隔 问题&#xff1a;翻译成英文后图例项之间重叠&#xff01; 解决&#xff1a;通过设置legend 组件的 itemGap 属性 解决后的效果&#xff1a;

uniapp中@input输入事件在修改值只有第一次有效的问题解决

在uniapp中使用输入框&#xff0c;要求输入不超过7个字&#xff0c;所以需要监听输入事件&#xff0c;当每次输入文字的时候&#xff0c;就把输入的值截断&#xff0c;取前7个值。但是在input事件中&#xff0c;重新赋值的值发生了变化&#xff0c;但是页面上的还是没有变&…

mac os设置jdk版本

打开环境变量配置文件 sudo vim ~/.bash_profile 设置不同的jdk版本路径 # 设置JAVA_HOME为jdk17路径 export JAVA_HOME$(/usr/libexec/java_home -v 17)# 设置JAVA_HOME为jdk8路径 export JAVA_HOME$(/usr/libexec/java_home -v 1.8) 设置环境变量 # 将jdk加入到环境变量…