当前位置： 首页 > article >正文

C/C++语言基础--C++STL库之仿函数、函数对象、bind、function简介

article 2024/12/22 15:02:01

本专栏目的

  • 更新C/C++的基础语法，包括C++的一些新特性

前言

  • STL无疑是C++史上一个重要的发明，未来我将更新STL有关的知识点，入门绝对够了(看目录就知道了👀)
  • 这是第二篇，讲仿函数
  • C语言后面也会继续更新知识点，如内联汇编；
  • 欢迎收藏 + 关注，本人将会持续更新。

文章目录

  • 仿函数
        • 可调用对象(Callable object)
        • 仿函数
        • 为什么要有仿函数？
        • 仿函数优点
        • 仿函数作用
    • 函数对象
      • 绑定函数
        • bind
        • not1
          • 一元函数又叫一元谓词
        • not
        • ref、cref
        • mem_fun
          • 示例
          • 总结
      • 包装类
        • funtion

仿函数

可调用对象(Callable object)

函数调用需要使用"()"，这个“()”叫做函数调用用运算符。

C++中的可调用对象有以下几种：

  • 函数（function）

  • 函数指针（function pointer）

  • 仿函数（Functor）

  • lambda表达式

  • bind 函数封装的函数对象

仿函数

仿函数（Functor）又称为函数对象（Function Object）是一个能行使函数功能的类，仿函数是定义了一个含有operator()成员函数的对象，可以视为一个一般的函数，只不过这个函数是通过类重载()所实现的。

为什么要有仿函数？

1，假如客户有一个需求摆在我们的面前,编写一个函数：

  • 函数可以获得斐波拉契数列每项的值；
  • 每调用一次便返回一个值；
  • 函数可根据需要重复使用。

普通函数实现：

int fibonacci()
{
	static int a0 = 0;	//第一项
	static int a1 = 1;	//第二项

	int ret = a1;		//保存
	a1 = a0 + a1;
	a0 = ret;

	return ret;
}
int main()
{
	for (size_t i = 0; i < 5; i++)
	{
		cout << fibonacci() << " ";		//1 1 2 3 5
	}
	cout << endl;
	for (size_t i = 0; i < 5; i++)
	{
		cout << fibonacci() << " ";		//8 13 21 34 55
	}
	return 0;
}

缺点 ：无法根据需求使用，如：无法想要重复获取一项值。

解决： 每一次从将初始项从新赋值为0。

int a0 = 0;	//第一项
int a1 = 1;	//第二项
int fibonacci()
{
	int ret = a1;
	a1 = a0 + a1;
	a0 = ret;

	return ret;
}

int main()
{
	for (size_t i = 0; i < 5; i++)
	{
		cout << fibonacci() << " ";		//1 1 2 3 5 8
	}
	cout << endl;

	a0 = 0;
	a1 = 1;
	for (size_t i = 0; i < 5; i++)
	{
		cout << fibonacci() << " ";		//1 1 2 3 5 8
	}
	return 0;
}

缺点： 无法直接获取一项值，如直接获取第9项值，而且每一次获取的时候还需要将初始值手动赋值为0；

解决： 函数对象

结合本案例，说明函数对象特点：

a> 使用具体的类对象取代函数；

b> 该类的对象具备函数调用的行为；

d>多个对象相互独立的求解数列项。

总结：函数对象利用运算符重载，使得对象可以想函数一样调用，但是对于类来说，他可以封装很多方法，很多变量，这个就可以实现普通函数完不成的东西，比如说：用成员变量储存过程数据。

解决：

class Fibonacci
{
public:
	Fibonacci() :_a0(0), _a1(1) {}
	Fibonacci(int n) :_a0(0), _a1(1) 
	{
		for (int i = 0; i < n; i++)
		{
			int ret = _a1;
			_a1 = _a0 + _a1;
			_a0 = ret;
		}
	}
	int operator()()
	{
		int ret = _a1;
		_a1 = _a0 + _a1;
		_a0 = ret;
		return ret;
	}
private:
	int _a0;
	int _a1;
};


int main()
{
	Fibonacci fib;
	for (size_t i = 0; i < 5; i++)
	{
		cout << fib() << " ";		//1 1 2 3 5 8
	}
	cout << endl;

	Fibonacci fib1(9);
	for (size_t i = 0; i < 5; i++)
	{
		cout << fib1() << " ";		//55 89 144 233 377
	}
	return 0;
}

我们看到已经实现了所有需求，并且随时想从哪个数开始都行。

仿函数优点

如果可以用仿函数实现，那么你应该用仿函数，而不要用CallBack。原因在于：

  • 仿函数可以不带痕迹地传递上下文参数。而CallBack技术通常使用一个额外的void*参数传递。这也是多数人认为CallBack技术丑陋的原因。
  • 仿函数技术可以获得更好的性能，这点直观来讲比较难以理解。
仿函数作用

仿函数通常有下面四个作用：

  • 作为排序规则，在一些特殊情况下排序是不能直接使用运算符<或者>时，可以使用仿函数。
  • 作为判别式使用，即返回值为bool类型。
  • 同时拥有多种内部状态，比如返回一个值得同时并累加。
  • 作为算法for_each的返回值使用。

函数对象

头文件

函数对象是专门设计用于使用类似于函数的语法的对象。在 C++ 中，这是通过operator()在其类中定义成员函数来实现的，它们通常用作函数的参数，例如传递给标准算法的谓词或比较函数，这个提出来个人感觉是为了替代函数指针，函数指针写起来确实比较麻烦。

绑定函数

这些函数根据其参数创建包装类的对象

bind

  • 它的作用是将一个可调用对象（比如函数、函数指针、成员函数、成员函数指针等等）以及若干个参数绑定到一个新的函数对象上，形成一个新的可调用对象。

  • 还可以用来绑定函数调用的某些参数，包括可以绑定参数顺序，可以将bind函数看作一个通用的函数包装器，它接受一个可调用对象，并返回函数对象。

  • ☄ 常用，这个的出现和std::function，其实就相当于替代了C的函数指针，使用起来更方便了。

1. 绑定普通函数

void show(int number, const std::string& str)
{
	cout << number << " " << str << endl;
}

  • 顺序绑定参数

    auto bind_show = std::bind(show, placeholders::_1, placeholders::_2);
bind_show(2,"world");

  • 交换参数位置

    auto bind_show1 = std::bind(show, placeholders::_2, placeholders::_1);
bind_show1("world",1314520);

  • 绑定固定参数

    auto bind_show3 = std::bind(show, 888,placeholders::_1);   //在函数调用的时候传递一个参数，一个在绑定的时候加
bind_show3("wy");

2. 绑定成员函数

😜 注意： 需要指明对象

struct Plus
{
	int plus(int a, int b)
	{
		return a * b;
	}
};	
{
	Plus plus;
	auto func1 = std::bind(&Plus::plus, &plus, placeholders::_1, placeholders::_2);	//绑定对象指针
    auto func2 = std::bind(&Plus::plus, plus, placeholders::_1, placeholders::_2);	//绑定对象或引用
	cout << func1(2, 4) << endl;
}

3. 绑定函数对象

struct Sub
{
	int operator()(int a, int b)
	{
		return a * b;
	}
};
{
	auto func2 = std::bind(Sub(), placeholders::_1, placeholders::_2);
	cout << func2(3, 4) << endl;
}

4. 绑定lambda表达式

{	
	auto func3 = std::bind([](int a, int b) {return a / b; }, placeholders::_1, placeholders::_2);
	cout << func3(6 ,2) << endl;
}
not1

对一元函数对象的否定，只能对仿函数进行否定，普通函数不行，这个有时候在看一些API的源码我们会看到有这个参数，其实这个就相当于bool函数，判断是否可行。

一元函数又叫一元谓词

谓词( predicate )是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator()接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词，谓词可作为一个判断式。

struct Greater5 
	:public unary_function<int, bool>		//必须继承自一元函数类
{
	bool operator()(int val) const			//必须加上const
	{
		return val > 5;
	}
};

int main()
{
	cout << boolalpha << Greater5()(10) << endl;
	auto _less5 = not1(Greater5());
	cout << boolalpha << _less5(10) << endl;
    return 0;
}
not

和上面不同的是，对二元函数对象的否定，还是只能对仿函数进行否定，普通函数不行。

struct Greater
    :public binary_function<int,int,bool>	//必须继承自二元函数类
{
	bool operator()(int a, int b) const		//必须加上const
	{
		return a > b;
	}
};

int main()
{
	cout << boolalpha << Greater()(3, 1) << endl;;

	auto _less = not2(Greater());
	cout << boolalpha << _less(3,1) << endl;;

	return 0;
}
ref、cref

上面提到，std::bind可以绑定函数参数，但是想要绑定引用参数，那如何做呢？ ref和cref这两个就是为了解决这个问题的。

  • ref 普通引用
  • cref 常引用
struct Inc
{
	mutable int number = 0;
	void operator()()const
	{
		cout << number << endl;
		number++;
	}
};

int main()
{
	Inc inc;
	auto func = bind(std::cref(inc));
	func();
	inc();
    return 0;
}
mem_fun

把成员函数转为函数对象，使用对象指针或对象(引用)进行绑定

class Foo
{
public:
	int a{ 100 };
	void print()
	{
		cout << a << endl;
	}
	void print2(int val)
	{
		cout << a << " val:" << val << endl;
	}
};

int main()
{
	Foo f;
	//把成员函数转为函数对象，使用对象指针或对象(引用)进行绑定
	auto func = mem_fn(&Foo::print);
	func(f);		//把对象传进去
	func(&f);		//对象指针也行
	func(Foo());	//临时对象也行

	//把成员函数转为函数对象，使用对象指针进行绑定
	auto func1 = mem_fun(&Foo::print2);
	func1(&f,666);

	//把成员函数转为函数对象，使用对象(引用)进行绑定
	auto func2 = mem_fun_ref(&Foo::print);
	func2(f);

	return 0;
}
示例
struct Foo
{
	int v;
	Foo(int val = -1)
		:v(val) {}
	void print()
	{
		cout <<v << endl;
	}
};

int main()
{
	//让每个对象都调用指定的成员函数
	std::vector<Foo> vec(5);	//存对象
	for_each(vec.begin(), vec.end(), mem_fn(&Foo::print));
	
	cout << endl;

	//让每个对象都调用指定的成员函数
	std::vector<Foo*> vec_ptr;	//存指针
	for (int i = 0; i < 5; i++)
	{
		vec_ptr.push_back(new Foo(i*3));
	}	
	for_each(vec_ptr.begin(), vec_ptr.end(), mem_fn(&Foo::print));

	return 0;
}
总结
函数作用
mem_fun把成员函数转为函数对象，使用对象指针进行绑定
mem_fun_ref把成员函数转为函数对象，使用对象(引用)进行绑定
mem_fn把成员函数转为函数对象，使用对象指针或对象(引用)进行绑定
bind包括但不限于mem_fn的功能，更为通用的解决方案

包装类

包装类是使不同的函数(普通函数、仿函数、bind绑定的一些函数…………)打包成具有统一接口一个类型，其中最常用的是function。

funtion

函数包装器

概念： C++11 中引入了 std::function 类型，它是一个多态函数封装类，可以用来存储和调用任意可调用对象，包括函数指针、函数对象、Lambda 表达式等等。

原因：因为不管是函数名、函数指针、仿函数还是lambda表达式，它们都是一个“函数”，function的作用是能够统一类型，从而提高效率。

与bind区别：

  • bind更多的是将函数和他的参数相互绑定在一起，可以使函数作为参数；
  • function主要是为“不同形状的函数”包装成统一类型，可以看下面的一些案例：

  1. 包装普通函数

    int add(int a, int b)
{
	return a + b;
}

{
    // 包装
	std::function<int(int, int)> fun_add(add);
	cout<<fun_add(2, 3);
}

  2. 包装成员函数(通过bind绑定)

    class Wy
{
public:
	int add(int a, int b)
	{
		return a + b;
	}
};

{
	Wy wy;
	std::function<int(int, int)> fun_maye_add(std::bind(&Wy::add, &wy,placeholders::_1,placeholders::_2));
	cout << fun_maye_add(3, 5);
}

  3. 包装lambda表达式(刷算法题常用)

    {
    std::function<int(int, int)> fun_lambda_add([](int a, int b)->int 
                                                    {
                                                        return a + b; 
                                                    });
	cout << fun_lambda_add(7, 8) << endl;    // 包装
}

  4. 包装函数对象

    class Maye
{
public:
	int operator()(int a, int b)
	{
		return a * b;
	}
};

{		
	Maye obj;
	std::function<int(int, int)> fun_functor(obj);
	cout << fun_functor(2,4);
}

http://www.kler.cn/a/446634.html

相关文章：

  • BlueLM：以2.6万亿token铸就7B参数超大规模语言模型
  • 「Mac畅玩鸿蒙与硬件46」UI互动应用篇23 - 自定义天气预报组件
  • 【D3.js in Action 3 精译_046】DIY 实战：在 Observable 平台利用饼图布局函数实现 D3 多个环形图的绘制
  • Hutool工具包的常用工具类的使用介绍
  • 多个Echart遍历生成 / 词图云
  • 【Lua热更新】上篇
  • 单元测试（C++）——gmock通用测试模版（个人总结）
  • Spring（三）-SpringWeb-概述、特点、搭建、运行流程、组件、接受请求、获取请求数据、特殊处理、拦截器
  • python实现word转html
  • AI大模型进一步推动了AI在处理图片、视频、音频、文本的等数据应用
  • 【新教程】非root用户给Ubuntu server设置开机自启服务-root用户给Ubuntu server设置开机自启服务
  • ArcGIS计算土地转移矩阵
  • 详细解释爬虫中的异常处理机制？
  • Rabbitmq实现延迟队列
  • Leetcode2545：根据第 K 场考试的分数排序
  • 26、基于SpringBoot的在线文档管理系统的设计与实现
  • R 基础运算
  • 基于卷积神经网络（CNN）和ResNet50的水果与蔬菜图像分类系统
  • 机器视觉检测相机基础知识 | 颜色 | 光源 | 镜头 | 分辨率 / 精度 / 公差
  • Leetcode 串联所有单词的子串
  • 【windows】sonarqube起不来的问题解决
  • 人脸修复与增强腾讯开源项目GFPGAN介绍
  • python rabbitmq实现简单/持久/广播/组播/topic/rpc消息异步发送可配置Django
  • Java爬虫实战：深度解析Lazada商品详情
  • 解决ubuntu22.04常见问题
  • Qt之串口设计-线程实现（十二）