现代c++急急急——functional、bind、lambda

已于 2023-07-02 13:15:01 修改
阅读量270 收藏
点赞数
分类专栏： 现代C++急急急 文章标签： c++ 开发语言 现代c++ functional lambda bind
于 2023-07-02 13:08:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51931826/article/details/131499979
版权

文章目录

现代c++急急急——functional、bind、lambda

bind前世今生

bind1st：operator()的第一个参数成为一个既定的值

bind2nd：operator()的第二个参数成为一个既定的值

从一个排序的例子开始

#include <iostream>
#include <functional>
#include <algorithm>
#include <vector>

using namespace std;

template<class T>
void MyPrint(T& container)
{
	for (auto x : container)
	{
		cout << x << ' ';
	}

	cout << endl;
}

int main()
{
	vector<int> vec;
	srand(time(NULL));
	for (int i = 0; i < 20; i++)
	{
		vec.push_back(rand() % 100 + 1);
	}
	MyPrint(vec);
	sort(vec.begin(), vec.end());
	//sort(vec.begin(), vec.end(), greater<int>());

	MyPrint(vec);

	return 0;
}

以上代码生成一个vector并从小到大排序

sort第三个参数支持自定义的排序方法，这里我们传入的是greater，实现从大到小排序，greater实现两个元素之间的比较

那么现在需要把70插入容器中，要求容器顺序不变，该怎么做？

在STL中有一个find_if可以在遍历某个容器的时候，按某个条件查找，比如说本次要求，只需要挨个拿容器中的某个元素和70进行比较，返回bool即可

但是我们注意到，find_if拿一个元素和一个既定的元素做比较，而greater或者less的都是拿两个元素做比较，有没有办法实现greater其中的一个元素固定下来呢？

这就是绑定器的作用，比如说让greater的第一个元素固定为70

#include <iostream>
#include <functional>
#include <algorithm>
#include <vector>

using namespace std;

template<class T>
void MyPrint(T& container)
{
	for (auto x : container)
	{
		cout << x << ' ';
	}

	cout << endl;
}

int main()
{
	vector<int> vec;
	srand(time(NULL));
	int num = 0;
	cin >> num;
	for (int i = 0; i < 20; i++)
	{
		vec.push_back(rand() % 100 + 1);
	}
	MyPrint(vec);
	sort(vec.begin(), vec.end(), greater<int>());
	auto res = find_if(vec.begin(), vec.end(), bind1st(greater<int>(), num));
	if (res != vec.end())
	{
		vec.insert(res, num);
	}

	MyPrint(vec);

	return 0;
}

同理，bind2nd也是一样的效果

可能的实现

find_if

// 取自cppreference
template<class InputIterator, class UnaryPredicate>
  InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (pred(*first)) return first;
    ++first;
  }
  return last;
}

bind1st

template<class Compare, class T>
class _MyBind1st
{
public:
	_MyBind1st(Compare cmp, T val) : _cmp(cmp), _val(val) {};
	bool operator()(const T& secondElement)
	{
		return _cmp(_val, secondElement);
	}
private:
	Compare _cmp;
	T _val;
};
template<class Compare, class T>
_MyBind1st<Compare, T> myBind1st(Compare cmp, const T& val)
{
	return _MyBind1st<Compare, T>(cmp, val);
}

最终效果

#include <iostream>
#include <functional>
#include <algorithm>
#include <vector>

using namespace std;

template<class T>
void MyPrint(T& container)
{
	for (auto x : container)
	{
		cout << x << ' ';
	}

	cout << endl;
}

template<class Compare, class T>
class _MyBind1st
{
public:
	_MyBind1st(Compare cmp, T val) : _cmp(cmp), _val(val) {};
	bool operator()(const T& secondElement)
	{
		return _cmp(_val, secondElement);
	}
private:
	Compare _cmp;
	T _val;
};
template<class Compare, class T>
_MyBind1st<Compare, T> myBind1st(Compare cmp, const T& val)
{
	return _MyBind1st<Compare, T>(cmp, val);
}

int main()
{
	vector<int> vec;
	srand(time(NULL));
	int num = 0;
	cin >> num;
	for (int i = 0; i < 20; i++)
	{
		vec.push_back(rand() % 100 + 1);
	}
	MyPrint(vec);
	sort(vec.begin(), vec.end(), greater<int>());
	auto res = find_if(vec.begin(), vec.end(), myBind1st(greater<int>(), num));
	if (res != vec.end())
	{
		vec.insert(res, num);
	}

	MyPrint(vec);

	return 0;
}

运行结果正确，由此可知，绑定器是函数对象的一种用法，使得某个函数的某个参数成为既定的参数(既定的意思并不是说右值)

今生

#include <iostream>
#include <functional>
#include <string>

using namespace std;

void Say(string str)
{
	cout << str << endl;
}

int main()
{
	auto res = bind(Say, "hello");
	res();
	return 0;
}

与1st和2nd不同的是，bind可以使得任意一个参数绑定为指定的参数，而不是固定的位置(如1st只能第一个参数变成指定的参数)

当然，bind也有1st和2nd的功能，也就是20个占位符，用于既定的位置的参数指定成给定的参数(很绕，我知道，这句话看一遍就好，不要深陷其中，看下面的例子)

一个实际的例子：

#include <iostream>
#include <functional>
#include <string>

using namespace std;

void Say(string str)
{
	cout << str << endl;
}

int main()
{
    // 指明Say函数的第一个参数(指定的位置)由用户指定
	auto res = bind(Say, placeholders::_1);
	res("hello");
	return 0;
}

以上效果便是第一个参数被指定为由用户给出的参数

函数对象

从hello开始

#include <iostream>
#include <functional>
#include <string>

using namespace std;

void SayStr(string str)
{
	cout << str << endl;
}

void Say()
{
	cout << "hello" << endl;
}

int main()
{
	function<void()> funcObj = Say;
	function<void(string)> funcObj2 = SayStr;
    
	funcObj();
	funcObj2("hello");

	return 0;
}

可以看到，函数对象有点类似于函数指针，但是背后原理其实是模板类，重载了()运算符，只是效果类似于函数指针，可以“指向”函数（注意有一个引号）

那么有趣的就是，函数这个概念，除了普通的函数，bind和lambda表达式都可以理解为返回了一个函数

除此之外，其实还有类内函数(比较重要的OOP手法)

#include <iostream>
#include <functional>
#include <string>

using namespace std;

class Say
{
public:
	void SayHello(string str) { cout << str << endl; };
};

int main()
{
	function<void(Say*, string)> funcObj = &Say::SayHello;
	Say tmpObj;
	funcObj(&tmpObj, "hello world");

	return 0;
}

通过以上例子，可以看出要使得functional可以“指向”类内函数，需要满足以下的条件

  • 类内函数为Public
  • 实例化function对象的函数签名需要有一个类的指针(也就是this指针)
  • 需要一个具体的类的对象

那么有趣的是，bind的参数也是一个函数，因此也可以通过传入的参数“指向”某个类的成员函数，这么做的好处是什么？

有点类似友元函数 + 回调函数的概念了，可以在不同的地方回调这个函数，极大的增加了代码的复用

可能的实现

#include <iostream>
#include <string>
#include <functional>

using namespace std;

void Say(string str)
{
    cout << str << endl;
}

template<class Fty>
class myFunction {};

template<class R, class Arg>
class myFunction<R(Arg)>
{
public:
    using pFunc = R(*)(Arg);
    myFunction(pFunc func) : func_(func) {};
    R operator() (Arg arg)
    {
        return func_(arg);
    };
private:
    pFunc func_;
};

int main()
{
    myFunction<void(string)> func(Say);
    func("hello world");

    return 0;
}

这里可以看出其实就是使用了函数指针来实现的，唯一的差别就是，这个实现只是一个参数，官方实现应该是可变参

// c++ insights的结果更容易看出实现
#include <iostream>
#include <string>
#include <functional>

using namespace std;

void Say(std::basic_string<char> str)
{
  std::operator<<(std::cout, str).operator<<(std::endl);
}


template<class Fty>
class myFunction
{
};

/* First instantiated from: insights.cpp:31 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class myFunction<void (std::basic_string<char>)>
{
  
  public: 
  using pFunc = void (*)(std::basic_string<char>);
  inline myFunction(pFunc func)
  : func_{func}
  {
  }
  
  inline void operator()(std::basic_string<char> arg)
  {
    return this->func_(std::basic_string<char>(arg));
  }
  
  
  private: 
  pFunc func_;
  public: 
};

#endif


template<class R, class Arg>
class myFunction<R (Arg)>
{
  
  public: 
  using pFunc = R (*)(Arg);
  inline myFunction(pFunc func)
  : func_{func}
  {
  }
  
  inline R operator()(Arg arg)
  {
    return this->func_(arg);
  }
  
  
  private: 
  pFunc func_;
};



int main()
{
  myFunction<void (std::basic_string<char>)> func = myFunction<void (std::basic_string<char>)>(Say);
  func.operator()(std::basic_string<char>("hello world", std::allocator<char>()));
  return 0;
}

lambda

语法格式：

[]<class T>()->{};

[]：捕获列表

<class T>：c++20新增的，也就是lambda表达式模板

()：函数参数列表

->：函数返回类型，c++11的语法，后置返回类型，也有叫尾置返回

{}：函数体

注意，有一个分号

再注意，lambda表达式模板是c++20的语法，此前的c++标准是没有的

lambda表达式的实现原理其实就是模板类，重载了()运算符

例子

从hello开始
#include <iostream>
#include <functional>
#include <string>

using namespace std;

void Say(string str)
{
	cout << str << endl;
}

int main()
{
	auto res = []()->void { cout << "hello" << endl; };
	res();

	return 0;
}

// c++ inights的结果
#include <iostream>
#include <functional>
#include <string>

using namespace std;

void Say(std::basic_string<char> str)
{
  std::operator<<(std::cout, str).operator<<(std::endl);
}


int main()
{
    
  class __lambda_14_13
  {
    public: 
    inline /*constexpr */ void operator()() const
    {
      std::operator<<(std::cout, "hello").operator<<(std::endl);
    }
    
    using retType_14_13 = auto (*)() -> void;
    inline constexpr operator retType_14_13 () const noexcept
    {
      return __invoke;
    };
    
    private: 
    static inline /*constexpr */ void __invoke()
    {
      __lambda_14_13{}.operator()();
    }
    
    
  };
  
  __lambda_14_13 res = __lambda_14_13{};
  res.operator()();
  return 0;
}

可以看到，lambda本质就是一个模板类 + 重载()运算符

带函数参数的lambda
#include <iostream>
#include <functional>
#include <string>

using namespace std;

void Say(string str)
{
	cout << str << endl;
}

int main()
{
	auto res = [](int a, int b)->int { return a + b; };
	cout << res(1, 2) << endl;

	return 0;
}
捕获外界变量的lambda
#include <iostream>
#include <functional>
#include <string>

using namespace std;

void Say(string str)
{
	cout << str << endl;
}

int val;

int main()
{
	int a = 0, b = 0;
	cin >> a >> b;
	// 值捕获
	auto res = [a, b]()->int { return a + b; };
	cout << res() << endl;

	// 引用捕获
	auto ans = [&a, &b]()->int { a++, b++; return a + b; };
	cout << ans() << endl;

	// 值捕获，但是捕获当前作用域所有变量：局部和全局
	auto cnt = [=]()->int { return val + b; };
	cout << cnt() << endl;

	// 引用捕获，但是捕获当前作用域所有变量：局部和全局
	auto tmp = [&]()->int { return val + b; };
	cout << tmp() << endl;
	return 0;
}

关于捕获列表，还有其他花活，比如说捕获this指针，值捕获，但是某些变量引用捕获以及一个比较重要的：值捕获，但是可以修改捕获的变量(mutable)，有兴趣可以自行了解

至于尾置返回类型，是可以省略的，如果省略了，就默认返回void

Azxcc0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11中lambda、std::function和std:bind详解
08-31
结合lambda表达式、std::function和std::bind，C++11提供了一套强大的工具，使得编写简洁、灵活且高度封装的代码成为可能。这些特性简化了回调函数的处理，提高了代码的可读性和维护性，是现代C++编程不可或缺的部分...
C++11新特性之 std::function 和 lambda 表达式
川峰的博客
11-06 350
c++11新增了std::function、std::bind、lambda表达式等封装使函数调用更加方便。
C++ Lambda Story - From C++98 to C++20.pdf
06-05
作者提醒读者，尽管`std::bind`在某些情况下仍然有用，但C++14和C++17引入的Lambda特性使得Lambda成为更现代、更推荐的选择，特别是在需要表达简洁的闭包时。 此外，书中提到了在线编译器的使用，如Coliru、Wandbox...
JQuery入门——用bind方法绑定事件处理函数应用介绍
10-27
`bind()`是jQuery中用于绑定事件处理函数的核心方法，对于初学者来说，掌握这个方法是理解jQuery事件处理的关键。 `bind()`方法的基本语法如标题和描述中所述：`bind(type, [data], fn)`。这里，`type`是一个或多个...
c/c++ 标准库 bind 函数详解
12-31
bind函数定义在头文件 functional 中。可以将 bind 函数看作一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。 bind函数：接收一个函数名作为参数，生成一个新的...
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1096
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 216
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 152
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 975
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
JNI: 在Kotlin和C++之间通过JNI进行接口传递，两边参数定义映射
tyfwin的博客
07-15 1033
在Kotlin和C++之间通过JNI进行接口传递时，需要注意两边参数定义的映射关系。JNI（Java Native Interface）为Java（Kotlin也适用）与本地语言（如C/C++）之间的交互提供了桥梁。在Kotlin中定义的外部函数和C++中的实现需要通过JNI签名相互对应。
【C++】获取环境变量
Badme
07-18 32
【C++】获取环境变量
【C++进阶学习】第六弹——set和map——体会用C++来构建二叉搜索树
2301_80220607的博客
07-12 4359
【C++进阶学习】第六弹——set和map——数据结构进阶知识点，适合初学者学习！！！
【C++修炼之路 第三章】内存管理：new 与 delete
最新发布
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-18 571
【含常见面试题】new & delete 的概念与用法 + 定位new表达式 + malloc/free 和 new/delete 的区别
C++ std::partial_sort_copy 用法
07-16 288
部分排序，即选出前n个最大值或者最小值，并将其保存到另外一个容器中。
C++中的多态：虚函数与纯虚函数详解
TheJustice_的博客
07-14 434
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 596
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。
C语言中的指针函数和函数指针
letterljhx的博客
07-18 284
C语言中的指针函数和函数指针
C语言 使用指针的2个小例子
waterHBO的博客
07-14 312
指针这部分，还是要多写多看，反复翻看笔记。
C++静态成员
2402_84626835的博客
07-14 190
对于类中的非静态数据成员，每一个类对象都拥有一个副本，即每个对象的同名数据成员可以分别存储不同的数值，这是保证每个对象拥有区别于其他对象的特征的需要。（1）由于在类的声明中仅仅是对静态数据成员进行了引用声明，因此必须在文件作用域的某个地方对静态数据成员进行定义并进行初始化，即应在类体外对静态数据成员进行初始化（静态数据成员的初始化与它的访问控制权限无关）。静态数据成员的值对每个对象都是一样的，它的值可以被任何一个对象更新，从而实现了同一类的不同对象之间的数据共享。9.1 静态数据成员。
C++的std::bind
06-07
std::bind是C++11标准中的一个函数模板，用于将可调用对象（函数、函数指针、成员函数、成员函数指针等）和其参数进行绑定，生成一个新的可调用对象。通过std::bind可以实现对函数参数进行延迟绑定、部分参数绑定、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值