笔记自用 【C++11】深入剖析lambda仿函数的原理,自己动手实现std::function容器
#include <iostream>
#include <functional>
int main()
{
int x = 2;
std::function<void()> f = [x]() {
printf("Hello %d!\n", x);
};
f();
auto g = f;
g();
return 0;
}
接下来我们将一步一步实现仿函数
函数指针有什么应用场景?函数指针可以用于设计模式中的策略模式
void func_hello() {
printf("Hello!\n");
}
void func_world() {
printf("World!\n");
}
typedef void (*pfunc_t)();
void repeat_twice(pfunc_t func) {
func();
func();
}
int main()
{
repeat_twice(func_hello);
repeat_twice(func_world);
return 0;
}
这段代码将会打印两遍Hello
,两编World
代码中的 typedef void (*pfunc_t)();
的含义是 void (*)()
描述了一个函数指针的类型,它指向一个没有参数并返回 void
的函数,pfunc_t
则是这种类型的新名称,不使用typedef
的写法如下:
void repeat_twice(void (*func)())
{
func();
func();
}
新的问题:如果函数的参数列表不一致怎么办?
新的处理:给函数添加参数列表void* arg
void func_hello(void* arg)
{
printf("Hello!\n");
}
void func_world(void* arg)
{
printf("World!\n");
}
void func_printnum(void* arg)
{
int x = *(int*)arg; // 将void*强制转换为int*
printf("%d\n", x);
}
typedef void (*pfunc_t)(void* arg);
void repeat_twice(pfunc_t func, void* arg)
{
func(arg);
func(arg);
}
int main()
{
int x;
std::cin >> x;
repeat_twice(func_hello, nullptr);
repeat_twice(func_world, nullptr);
repeat_twice(func_printnum, &x);
return 0;
}
新的问题:如果存在多个参数怎么办,比如一个
x
一个y
?
新的处理:我们可以定义一个结构体
struct prinnum_args_t {
int x;
int y;
};
void func_printnum(void *arg)
{
auto a = (prinnum_args_t *)arg;
printf("Numbers are %d, %d\n", a->x, a->y);
}
typedef void (*pfunc_t)(void *arg);
void repeat_twice(pfunc_t func, void *arg)
{
func(arg);
func(arg);
}
int main()
{
int x, y;
std::cin >> x >> y;
prinnum_args_t a;
a.x = x;
a.y = y;
repeat_twice(func_printnum, &a);
return 0;
}
新的问题:上面这段代码实现了对x,y变量的捕获,但是当x y的值改变的时候我们还需要再次填充
prinnum_args_t a
,如何让函数打印的值能够跟随 x y 本身变换呢?
int x, y;
std::cin >> x >> y;
repeat_twice(func_hello, nullptr);
repeat_twice(func_world, nullptr);
prinnum_args_t a;
a.x = x;
a.y = y;
repeat_twice(func_printnum, &a);
std::cin >> x >> y; // x y 发生改变
a.x = x; // 需要再次填充prinnum_args_t
a.y = y;
repeat_twice(func_printnum, &a);
新的处理:需要使用指针或者引用来实现变量的同步变化
struct prinnum_args_t {
int &x;
int &y;
};
void func_printnum(void *arg)
{
auto a = (prinnum_args_t *)arg;
printf("Numbers are %d, %d\n", a->x, a->y);
}
typedef void (*pfunc_t)(void *arg);
void repeat_twice(pfunc_t func, void *arg)
{
func(arg);
func(arg);
}
int main()
{
int x, y;
std::cin >> x >> y;
prinnum_args_t a{x, y};
repeat_twice(func_printnum, &a);
std::cin >> x >> y;
repeat_twice(func_printnum, &a); // 将会打印新的 x y 值
return 0;
}
可以直接将这个函数作为结构体的成员函数,从而实现这个结构体就是函数本身,这就是仿函数的起源
struct prinnum_args_t {
void call()
{
printf("Numbers are %d, %d\n", x, y);
}
int &x;
int &y;
};
template <class Fn>
void repeat_twice(Fn func)
{
func.call();
func.call();
}
int main()
{
int x, y;
std::cin >> x >> y;
prinnum_args_t a{x, y};
repeat_twice(a);
std::cin >> x >> y;
repeat_twice(a);
return 0;
}
事实上,现在我们可以直接重载
operator()
,也即在类内部定义operator()函数,它将作为类的调用操作
struct prinnum_args_t {
void operator()()
{
printf("Numbers are %d, %d\n", x, y);
}
int &x;
int &y;
};
template <class Fn>
void repeat_twice(Fn func)
{
func();
func();
}
int main()
{
int x, y;
std::cin >> x >> y;
prinnum_args_t a{x, y};
repeat_twice(a);
std::cin >> x >> y;
repeat_twice(a);
return 0;
}
再加上
const
,便于处理const
参数
struct prinnum_args_t {
void operator()() const
{
printf("Numbers are %d, %d\n", x, y);
}
int &x;
int &y;
};
template <class Fn>
void repeat_twice(Fn const &func)
{
func();
func();
}
然后我们可以对比一下c++的仿函数,本质上和我们上面实现的这个类是一样的,只是使用了一个语法糖
c++ 仿函数本质上就是使用了一个语法糖构造了一个类,然后调用了这个类的operator()方法
int main()
{
int x, y;
std::cin >> x >> y;
prinnum_args_t a{x, y};
// c++ 仿函数本质上就是使用了一个语法糖构造了一个类,然后调用了这个类的operator()方法
repeat_twice([&x, &y]() { printf("Numbers are %d, %d\n", x, y); });
std::cin >> x >> y;
repeat_twice(a);
return 0;
}
也即 repeat_twice([&x, &y]() { printf("Numbers are %d, %d\n", x, y); });
等价于
c++内置的这个仿函数调用的也是一个
const
函数,可以看到x
通过引用捕获,y
通过值捕获时,可以修改x,但不能修改y
为了便于理解,这个仿函数等价于下面这个类
如果想修改,需要加上mutable
来去除const
新的问题:仿函数怎么传入参数?
新的处理:operator()
可以直接接收参数
struct func_prinnum_t {
void operator()(int i) const // 传入参数 int i
{
printf("#%d Numbers are %d, %d\n", i, x, y);
}
int x;
int y;
};
template <class Fn>
void repeat_twice(Fn const &func)
{
func(1);
func(2);
}
int main()
{
int x, y;
std::cin >> x >> y;
repeat_twice([=](int i) { // 传入参数 int i
printf("#%d Numbers are %d, %d\n", i, x, y);
});
printf("----------------\n");
func_prinnum_t func_prinnum{x, y};
repeat_twice(func_prinnum);
return 0;
}
新的问题:由于使用了模板,所以无法实现声明和定义的分离,得写在一个文件里面,很不方便
待解读 Function.hpp