502-C++的绑定器(讲解大全)

最新推荐文章于 2024-04-01 04:27:02 发布
最新推荐文章于 2024-04-01 04:27:02 发布
阅读量585 收藏
点赞数 2
分类专栏： C++的学习 文章标签： c++ bind
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LINZEYU666/article/details/119984449
版权
本文详细介绍了C++中的函数对象，包括STL中的绑定器bind1st和bind2nd，以及C++11引入的bind绑定器和function函数对象。通过示例展示了如何使用这些工具实现一元和二元函数对象，以及如何利用它们进行函数参数的预设定。此外，文章还提及了lambda表达式的底层机制，并讨论了C++11的function在实际应用中的示例，如用于管理各种操作的映射表。
摘要由CSDN通过智能技术生成

绑定器和函数对象operator()

1.C++ STL中的绑定器
bind1st : operator()的第一个形参变量绑定成一个确定的值
bind2nd : operator()的第二个形参变量绑定成一个确定的值

2.C++11从Boost库中引入了bind绑定器和function函数对象机制

3.lambda表达式 底层依赖函数对象的机制实现的

我们先准备好环境

在这里插入图片描述

#include <iostream>
#include <vector> 
#include <functional>
#include <algorithm>
#include <ctime>
using namespace std;

template<typename Container>
void showContainer(Container& con)
{
	typename Container::iterator it = con.begin();
	//编译器是从上到下编译的，这个还没有实例化，它不知道这个名字作用域后面的iterator是类型还是变量
	//typename告知编译器后面类型的作用域后面是类型
	for (; it != con.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	vector<int> vec;
	srand(time(nullptr));
	for (int i = 0; i < 20; ++i)
	{
		vec.push_back(rand() % 100 + 1);//随机出来的数字，并不是有序的 
	}

	showContainer(vec);
	sort(vec.begin(), vec.end());//默认小到大排序，传入的是起始和末尾的后继的迭代器
	showContainer(vec);
	//greater 二元函数对象
	sort(vec.begin(), vec.end(), greater<int>());//大到小排序
	showContainer(vec);
	return 0;
}

在这里插入图片描述

C++ STL的绑定器

在这里插入图片描述

把70按顺序插入到vec容器当中，找第一个小于70的数字

#include <iostream>
#include <vector> 
#include <functional>
#include <algorithm>
#include <ctime>
using namespace std;

template<typename Container>
void showContainer(Container& con)
{
	typename Container::iterator it = con.begin();
	for (; it != con.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}

template<typename Iterator, typename Compare>
Iterator my_find_if(Iterator first, Iterator last, Compare comp)
//遍历这2个迭代器之间的元素，如果满足函数对象的运算，就返回当前迭代器，如果都不满足，返回end()
{
	for (; first != last; ++first)
	{
		if (comp(*first))//comp.operator()(*first)一元函数对象，因为要从容器拿1个元素和它指定的元素比较
		//my_find_if需要1元函数对象，而在库里面都是二元的
		{
			return first;
		}
	}
	return last;
}

template<typename Compare, typename T>
class _mybind1st//绑定器是函数对象的一个应用
{
public:
	_mybind1st(Compare comp, T val)
		:_comp(comp), _val(val)
	{}
	bool operator()(const T& second)
	{
		return _comp(_val, second);//greater
	}
private:
	Compare _comp;
	T _val;
};

//mybind1st(greater<int>(), 70)
template<typename Compare, typename T>
_mybind1st<Compare, T> mybind1st(Compare comp, const T& val)
{
	//直接使用函数模板，好处是，可以进行类型的推演
	return _mybind1st<Compare, T>(comp, val);
}

int main()
{
	vector<int> vec;
	srand(time(nullptr));
	for (int i = 0; i < 20; ++i)
	{
		vec.push_back(rand() % 100 + 1);
	}

	showContainer(vec);
	sort(vec.begin(), vec.end());//默认小到大排序
	showContainer(vec);

	//greater 二元函数对象
	sort(vec.begin(), vec.end(), greater<int>());//大到小排序
	showContainer(vec);

	/*
	把70按顺序插入到vec容器当中   找第一个小于70的数字
	operator()(const T &val)
	greater   a > b
	less      a < b
	绑定器 + 二元函数对象 =》 一元函数对象
	bind1st: + greater bool operator()(70, const _Ty& _Right)
	bind2nd: + less bool operator()(const _Ty& _Left, 70)
	*/

	auto it1 = my_find_if(vec.begin(), vec.end(),
		mybind1st(greater<int>(), 70));
	//auto it1 = my_find_if(vec.begin(), vec.end(),bind2nd(less<int>(), 70));
	if (it1 != vec.end())
	{
		vec.insert(it1, 70);
	}
	showContainer(vec);

	return 0;
}

在这里插入图片描述

C++ 11的绑定器（function使用示例）

在这里插入图片描述

void hello1()
{
	cout << "hello world!" << endl;
}
void hello2(string str)//void (*pfunc)(string)
{
	cout << str << endl;
}
int sum(int a, int b)
{
	return a + b;
}

class Test
{
public://必须依赖一个对象void (Test::*pfunc)(string)
	void hello(string str) { cout << str << endl; }
};

int main()
{
	/*
	1.用函数类型实例化function
	2.通过function调用operator()函数的时候，需要根据函数类型传入相应的参数
	*/

	//从function的类模板定义处，看到希望用一个函数类型实例化function
	function<void()> func1 = hello1;
	func1();//func1.operator()() => hello1()

	function<void(string)> func2 = hello2;
	func2("hello hello2!");//func2.operator()(string str) => hello2(str)

	function<int(int, int)> func3 = sum;
	cout << func3(20, 30) << endl;

	//operator()
	function<int(int, int)> func4 = [](int a, int b)->int {return a + b; };
	cout << func4(100, 200) << endl;

	function<void(Test*, string)> func5 = &Test::hello;
	func5(&Test(), "call Test::hello!");

	return 0;
}

#include <iostream>
#include <vector> 
#include <map>
#include <functional>//使用function函数对象类型
#include <algorithm>
#include <ctime>
#include <string>
using namespace std;


void doShowAllBooks() { cout << "查看所有书籍信息" << endl; }
void doBorrow() { cout << "借书" << endl; }
void doBack() { cout << "还书" << endl; }
void doQueryBooks() { cout << "查询书籍" << endl; }
void doLoginOut() { cout << "注销" << endl; }

int main()
{
	int choice = 0;
	//      C的函数指针
	map<int, function<void()>> actionMap;
	actionMap.insert({ 1, doShowAllBooks });//老版本：insert(make_pair(xx,xx));
	actionMap.insert({ 2, doBorrow });
	actionMap.insert({ 3, doBack });
	actionMap.insert({ 4, doQueryBooks });
	actionMap.insert({ 5, doLoginOut });

	for (;;)
	{
		cout << "-----------------" << endl;
		cout << "1.查看所有书籍信息" << endl;
		cout << "2.借书" << endl;
		cout << "3.还书" << endl;
		cout << "4.查询书籍" << endl;
		cout << "5.注销" << endl;
		cout << "-----------------" << endl;
		cout << "请选择:";
		cin >> choice;

		auto it = actionMap.find(choice);//map  pair  first second
		if (it == actionMap.end())
		{
			cout << "输入数字无效，重新选择!" << endl;
		}
		else
		{
			it->second();
		}
		//不好，因为这块代码无法闭合  无法做到“开-闭原则”
		/*switch (choice)
		{
		case 1:
			break;
		case 2:
			break;
		case 3:
			break;
		case 4:
			break;
		case 5:
			break;
		default:
			break;
		}*/
	}

	return 0;
}

在这里插入图片描述

模板的完全特例化和部分特例化

模板的完全特例化和非完全（部分）特例化
模板的实参推演 => 基本概念很简单

有完全特例化，就选择对应的完全特例化，有部分特例化，就匹配部分特例化，没有的话，就原模板实例化

示例1

template<typename T>
bool compare(T a, T b)
{
	cout << "template compare" << endl;
	return a > b;
}
template<>
bool compare<const char*>(const char*a, const char*b)//特例化 
{
	cout << "compare<const char*>" << endl;
	return strcmp(a, b) > 0;
}
int main()
{
	compare(10, 20);// 
	compare("aaa", "bbb");//T const char*
	return 0;
}

第二个是特例化了。
在这里插入图片描述
示例2

template<typename T>
class Vector 
{
public:
	Vector() { cout << "call Vector template init" << endl; }
};
//下面这个是对char*类型提供的完全特例化版本  #1
template<>//特例化的语法
class Vector<char*>
{
public:
	Vector() { cout << "call Vector<char*> init" << endl; }
};
//下面这个是对指针类型提供的部分特例化版本  #2
template<typename Ty>
class Vector<Ty*>
{
public:
	Vector() { cout << "call Vector<Ty*> init" << endl; }
};

//指针函数指针（有返回值，有两个形参变量）提供的部分特例化
template<typename R, typename A1, typename A2>
class Vector<R(*)(A1, A2)>
{
public:
	Vector() { cout << "call Vector<R(*)(A1, A2)> init" << endl; }
};

//针对函数（有一个返回值，有两个形参变量）类型提供的部分特例化
template<typename R, typename A1, typename A2>
class Vector<R(A1, A2)>
{
public:
	Vector() { cout << "call Vector<R(A1, A2)> init" << endl; }
};

int sum(int a, int b) { return a + b; }
int main()
{
	Vector<int> vec1;
	Vector<char*> vec2;
	Vector<int*> vec3;
	Vector<int(*)(int, int)> vec4;
	Vector<int(int, int)> vec5;//function

	//注意区分一下函数类型和函数指针类型
	typedef int(*PFUNC1)(int, int);
	PFUNC1 pfunc1 = sum;
	cout << pfunc1(10, 20) << endl;

	typedef int PFUNC2(int, int);
	PFUNC2 *pfunc2 = sum;
	cout << (*pfunc2)(10, 20) << endl;

	return 0;
}

在这里插入图片描述

模板的实参推演

#include <iostream>
#include <typeinfo>
using namespace std;


int sum(int a, int b) { return a + b; }
//T包含了所有的大的类型  返回值，所有形参的类型都取出来
template<typename T>
void func(T a)
{
	cout << typeid(T).name() << endl;
}

template<typename R, typename A1, typename A2>
void func2(R(*a)(A1, A2))
{
	cout << typeid(R).name() << endl;
	cout << typeid(A1).name() << endl;
	cout << typeid(A2).name() << endl;
}

class Test
{
public:
	int sum(int a, int b) { return a + b; }
};

template<typename R, typename T, typename A1, typename A2>
void func3(R(T::* a)(A1, A2))
{
	cout << typeid(R).name() << endl;
	cout << typeid(T).name() << endl;
	cout << typeid(A1).name() << endl;
	cout << typeid(A2).name() << endl;
}
int main()
{
	func(10);
	func("aaa");
	func(sum);//T  int (*)(int,int)   int (int,int)
	func2(sum);
	func3(&Test::sum);//int (__thiscall Test::*)(int,int)

	return 0;
}

在这里插入图片描述

function的实现原理

#include <iostream>
#include <typeinfo>
#include <string>
#include <functional>
using namespace std;

/*
function函数对象类型的实现原理
*/
void hello(string str) { cout << str << endl; }
int sum(int a, int b) { return a + b; }
///
template<typename Fty>
class myfunction {};

 
template<typename R, typename A1>
class myfunction<R(A1)>
{
public:
	using PFUNC = R(*)(A1);
	myfunction(PFUNC pfunc) :_pfunc(pfunc) {}
	R operator()(A1 arg)
	{
		return _pfunc(arg);//hello(arg)
	}
private:
	PFUNC _pfunc;
};

///
template<typename R, typename A1, typename A2>
class myfunction<R(A1, A2)>
{
public:
	using PFUNC = R(*)(A1, A2);
	myfunction(PFUNC pfunc) :_pfunc(pfunc) {}
	R operator()(A1 arg1, A2 arg2)
	{
		return _pfunc(arg1, arg2);//hello(arg)
	}
private:
	PFUNC _pfunc;
};
//

template<typename R, typename... A>//一组可变参数个数
class myfunction<R(A...)>
{
public:
	using PFUNC = R(*)(A...);
	myfunction(PFUNC pfunc) :_pfunc(pfunc) {}
	R operator()(A... arg)
	{
		return _pfunc(arg...);//hello(arg) 表示一组形参变量
	}
private:
	PFUNC _pfunc;
};

int main()
{
	function<void(string)> func1(hello);
	func1("hello world!");//func1.operator()("hello world!")

	myfunction<int(int, int)> func2(sum);
	cout << func2(10, 20) << endl;

	return 0;
}

C++11 绑定器介绍

C++11 bind绑定器 => 返回的结果还是一个函数对象
bind占位符最多有20个参数。

#include <iostream>
#include <typeinfo>
#include <string>
#include <memory>
#include <vector>
#include <functional>
#include <thread>
using namespace std;
using namespace placeholders;

/*
C++11 bind绑定器 => 返回的结果还是一个函数对象
*/

void hello(string str) { cout << str << endl; }
int sum(int a, int b) { return a + b; }
class Test
{
public:
	int sum(int a, int b) { return a + b; }
};
int main()
{
	//bind是函数模板 可以自动推演模板类型参数
	bind(hello, "hello bind!")();//返回的结果是绑定器，也就是函数对象 
	cout << bind(sum, 10, 20)() << endl;
	cout << bind(&Test::sum, Test(), 20, 30)() << endl;

	//参数占位符  绑定器出了语句，无法继续使用
	//只是占位的作用，调用的时候就要传递参数了 
	//书写的时候使用多少个占位符，就是意味着用户调用的时候要传入几个参数
	bind(hello, _1)("hello bind 2!");
	cout << bind(sum, _1, _2)(200, 300) << endl;

	//此处把bind返回的绑定器binder就复用起来了
	function<void(string)> func1 = bind(hello, _1);
	func1("hello china!");
	func1("hello shan xi!");
	func1("hello si chuan!");

	return 0;
}

在这里插入图片描述

在这里插入图片描述
有20个参数占位符

林林林ZEYU
关注
专栏目录
【手撕代码】手动实现一个bind1st和bind2nd绑定器
weixin_42226134的博客
04-01 265
// 08 C++绑定器和函数对象.cpp : 此文件包含 “main” 函数。程序执行将在此处开始并结束。 // #include “pch.h” #include #include #include #include #include using namespace std; #if 0 /* 绑定器和函数对象operator() 1.C++ STL中的绑定器 bind1st : o...
C++绑定器
weixin_43519366的博客
04-10 119
C++绑定器和函数对象 下面展示一些 内联代码片。 #include <iostream> #include <vector> #include <functional> #include <algorithm> #include <ctime> using namespace std; /* 绑定器和函数对象operator() 1.C++ STL中的绑定器 bind1st : operator()的第一个形参变量绑定成一个确定的值 b
C++中function和bind是如何实现的
10-25
C++里面的function是一个非常奇妙的东西，但是你想过他是如何实现的吗？作者在深刻理解了其中奥妙之后写就的精简版本。而且可以避免STL里面的function无法和Socket编程一起使用的问题——bind会无法正确解析。
c++ function和bind
qq_44698445的博客
07-19 740
为什么要用std::function 因为 函数指针,函数对象,匿名函数都可以作为调用对象 即高阶函数调用对象 然而并不是所有函数都可以被高阶函数调用因此要用function 列如类 function 可以创建对象 他可以接受任意类型可以调用对象 而且还可以用数组存储一个函数容器 但是函数参数格式必须一样 std::bind 是一个函数适配器 他接收一个函数和一组实参 返回一个function函数对象 using namespace std::placeholders; // bind如果不想过早传递参数可
C++中的绑定器
qq_41078889的博客
01-05 257
STL中的绑定器 bind1st: operator() 的第一个形参变量绑定成一个确定的值。 bind2nd: operator() 的第二个形参变量绑定成一个确定的值。 绑定器加二元函数对象得到一个一元函数对象 int main() { vector<int> vec; srand(time(nullptr)); for (int i = 0; i < 20; ++i) { vec.push_back(rand() % 100 + 1); } sort(ve
c++function和bind
dz131lsq的博客
03-05 596
在c++11中提供了两个方法std::bind和std::function对回调对象进行封装。主要是在使用回调函数的时候进行使用。function可以看作一个包装器，对可调用对象进行包装。c++里面的可调用对象包括:函数，函数指针，lambda表达式，bind创建的对象，重载了函数调用运算符的类。
inside-c++object-model.rar_inside_inside the c++
09-19
本书详细讲解了C++对象模型的各个方面，包括类、对象、继承、多态等核心概念在内存中的表示以及编译器如何实现这些特性。 1. **C++对象模型基础**：C++对象模型是C++语言在内存中的抽象表示，包括对象的创建、生命...
Master-Class-C++11.pdf
05-13
在这份培训资料中，涉及到了C++11的许多新特性，其中包括新库的介绍以及一些关键概念的讲解。以下是一些培训中的关键知识点： 1. 新的库特性： - <chrono>：提供时间点、时长和时钟的处理功能。 - <regex>：增加...
网易云课堂视频转存：面向对象程序设计-C++（视频） 浙江大学 翁恺老师
05-24
8. 模板和STL：C++的泛型编程工具，以及标准模板库（Standard Template Library）的使用，如容器（vector、list、set等）、迭代器、算法等。 9. 异常处理：学习如何在程序中捕获和处理错误，提高程序的健壮性。 10...
C/ c++库的绑定和包装生成器
01-27
在IT行业中，C和C++库的绑定和包装生成器是一种工具，用于让其他编程语言能够无缝地调用C或C++编写的库。这样的工具极大地扩展了代码的可复用性和互操作性，尤其在多语言混合开发的项目中显得尤为重要。本篇文章将...
C++ | function和bind
wekidi的博客
04-17 684
可调用对象 可调用对象的定义:(满足一个即可) 是一个函数指针 是一个具有operator()成员函数的类对象(就是仿函数) 是一个可被转换为函数指针的类对象 是一个类成员(函数)指针 关于一个可被转换为函数指针的类对象的举例: struct Bar { using fr_t = void(*) (void);//返回值为空参数为空的函数指针类型定义为fr_t static void func(void) { //... } operator fr_t(void) { return f
C++ function＜＞和bind()
weixin_42463482的博客
09-17 410
介绍两个概念：调用运算符和可调用对象。
C++之function和bind用法
axyw_的博客
09-26 1136
C++11特性function和bind的用法
C++_Function包装器和bind
最新发布
fengjunziya的博客
04-01 344
到目前为止的学习，我们知晓了三种方式来传函数。
C++bind和function
Tzecto
05-12 1035
C++ STL中的绑定器 bind1st : operator()的第一个形参变量绑定成一个确定的值 bind2nd : operator()的第二个形参变量绑定成一个确定的值 绑定器 + 二元函数对象 =》 一元函数对象 把70按顺序插入到vec容器当中 找第一个小于70的数字 operator()(const T &val) greater a > b less a < b 绑定器 + 二元函数对象 =》 一元函数对象 bind1st: + greater bool
c++11新特性——function和bind
weixin_46935110的博客
07-27 452
c++11新特性——function和bind
面向对象程序设计-C++语言深入解析
书中讲解了函数的值和类型、返回语句的使用、类与对象、继承与派生、多态性和虚函数等内容，旨在帮助读者深入理解和掌握C++的面向对象特性。" 在面向对象程序设计中，C++是关键的编程语言之一，它在C语言的基础上...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林林林ZEYU

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值