没有合适的资源?快使用搜索试试~ 我知道了~
2. 可调用对象 function1
需积分: 0 0 下载量 77 浏览量
2022-08-03
17:14:23
上传
评论
收藏 513KB PDF 举报
温馨提示
试读
1页
简介C++ 中的可调对象普通函数foo 为个函数对象,函数对象当然是可调对象,函数来就是被调的public:};此时 Buz 类的对象可调,因为我们重载了 op
资源详情
资源评论
资源推荐
可
调
⽤
对
象
function
简
介
C++
中
的
可
调
⽤
对
象
普
通
函
数
void foo(int size) { /* ...... */ }
foo(1024);
foo
为⼀个
函
数
对
象
,
函
数
对
象
当
然
是
可
调
⽤
对
象
,
函
数
⽣
来
就
是
被
调
⽤
的
重
载
了
operator()
的
class
class Buz {
public:
void operator() (int size) { /* ...... */ }
};
Buz buz;
buz(1024);
此
时
Buz
类
的
对
象
可
调
⽤
,
因
为
我
们
重
载
了
operator()
函
数
,
或
者
说
,
重
载
了
“
函
数
调
⽤
运
算
符
”
lambda
表
达
式
C++11
引
⼊
,
本
质
上
是
⼀个
匿
名
函
数
auto f = [](int size) { /* ...... */ };
f(1024);
这
3
个
可
调
⽤
对
象
的
形
参
和
返
回
值
均
相
同
,
我
们
可
以
说
它
们
的
调
⽤
形式
相
同
std::function
既
然
前
⾯
有
3
中
可
调
⽤
对
象
,
那
么
,
我
们
是
否
可
以
使
⽤
⼀个
函
数
指
针
来
保
存
这
3
个
可
调
⽤
对
象
呢
?
void (*ptr)(int);
ptr = foo; // right
ptr = f; // right
ptr = buz; // wrong
可
以
看
到
,
尽
管
buz
是
⼀个
可
调
⽤
对
象
,
但
是
编
译
器
并
不
认
为
它
能
够
赋
值
给
函
数
指
针
,
这
样
的
”
差
别
对
待
“
将
会
影
响
到
我
们
使
⽤
C++
来
进
⾏
函
数
式
编
程
⽐
如
说
我
们
有
⼀个
handler
,
接
收
⼀个
可
调
⽤
对
象
和
其
参
数
,
那
么
我
们
就
需
要
单
独
的
对
可
调
⽤
类
对
象
进
⾏
函
数
重
载
此
时
我
们
就
可
以
使
⽤
std::fuction
类
模
板
,
其
参
数
类
型
为
对
象
的
调
⽤
形式
,
例
如
int(int
,
double)
表
⽰
返
回
值
为
int
,
形
参
分别
为
int
、
double
的
调
⽤
形式
这
时
候
我
们
就
可
以
把
buz
丢
进
去
了
#include <functional>
std::function<void(int)> f1 = foo;
std::function<void(int)> f2 = f;
std::function<void(int)> f3 = buz;
handler
就
可
以
这
样
写
void handler(std::function<void(int)>& func, int arg) {
func(arg);
}
std::function
中
定
义了
完
整
的
拷
⻉
控
制函
数
,
也
就
是
说
,
我
们
既
可
以
拷
⻉
和
移
动
该
类
模
板
的
实
例
对
象
std::bind
作
⽤
std::bind
⾮
常
类
似
于
Python
中
的
functools.partial()
,
⽬
的
就
是
为了
减
少
可
调
⽤
对
象
的
参
数
个
数
Python
def func(a, b, c, d):
print(a, b, c, d)
if __name__ == "__main__":
s1 = partial(func, 10, 20) # fill a
、
b
s2 = partial(func, 10, 20, d=40) # fill a
、
b
、
d
s1(30, 40)
func()
函
数
本
⾝
接
收
4
个
参
数
,
但
是
我
们
可
以
使
⽤
partial
⽅
法
给
该
函
数
填
充
⼀
部
分
的
参
数
,
函
数
返
回
另
⼀个
可
调
⽤
对
象
。
此
时
我
们
只
需
要
再
提
供
c
、
d
两个
参
数
即
可
C++
void foo(int a, int b, int c, int d) {
printf("%d-%d-%d-%d", a, b, c, d);
}
int main () {
using std::placeholders::_1, std::placeholders::_2;
auto f = std::bind(foo, 10, 20, _1, _2);
f(30, 40);
}
C++
中
的
std::bind
就
没
有
partial
那
么
智
能
了
,
我
们
必
须
要
使
⽤
诸
如
_1, _2
的
占
位
符
对
形
参
进
⾏
占
位
std::bind(foo, 10, 20);
这
样
的
写
法
编
译
器
并
不
会
⾃
动
地
去
推
断
“
还
剩
两个
形
参
”
,
也
就
是
说
,
这
么
写
是
不
对
的
即
虽
然
std::bind
允
许
我
们
预
先
为⼀个
可
调
⽤
对
象
添
加
部
分
参
数
,
但
是
剩
余
的
参
数
必
须
使
⽤
诸
如
std::placeholders::_1
、
std::placeholders::_2
等
占
位
符
进
⾏
占
位
,
必
须
保
证
形
参
个
数
保
持
⼀
致
这
么
做
也
带
来
了
另
外
⼀个
好
处
:
灵
活
性
⼤⼤
增
强
我
们
可
以任
意
的
调
整
_1
、
_2
等
占
位
符
的
位
置
来
表
⽰
缺
省
的
函
数
形
参
std::bind(foo, _1, 10, 20, _2); //
此
时
b = 10, c = 20
std::bind(foo, 10, _1, 20, _2); //
此
时
a = 10, c = 20
通
常
来
说
我
们会
使
⽤
std::function<>
来
代
替
使
⽤
auto
,
使
得
代
码
更
加
清
晰
std::function<void(int, int)> f = std::bind(foo, 10, 20, _1, _2);
f(30, 40);
绑
定
普
通
函
数
当
普
通
函
数
作
为
实
参
时
,
在
调
⽤
std::bind()
时
将
会
默
认
的
转
换
成
函
数
指
针
。
也
就
是
说
,
std::bind(&foo, _1, 10, 20, _2);
这
么
写
也
是
可
以
的
绑
定
成
员
函
数
和
std::thread
⼀
样
,
当
我
们
绑
定
成
员
函
数
时
,
⾸
先
需
要
显
式
地
使
⽤
诸
如
&Buz::func
的
⽅
式
将
成
员
函
数
转
换
成
函
数
指
针
其
次
,
因
为
在
调
⽤
成
员
函
数
时
需
要
知
道
该
对
象
的
归
属
,
所
以
我
们
还
需
要
把
对
象
传
⼊
,
也
就
是
"this pointer"
class Buz {
public:
void foo(const string& s) {/* ...... */}
};
Buz buz;
std::function<void()> f = std::bind(&Buz::foo, &buz, "hello");
如
果
要
绑
定
引
⽤
类
型
参
数
的
话
,
请
使
⽤
std::ref
泡泡SOHO
- 粉丝: 22
- 资源: 294
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功
评论0