C++20 functional (tcy)

2024-03-20 08:58
文章标签 c++ 20 functional tcy

本文主要是介绍C++20 functional (tcy),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

 第一部分:概述

1.1.命名空间	placeholders			为std :: bind表达式中的未绑定参数定义占位符std::placeholders		常数在名称空间中定义 std::placeholders	_1, _2, _3, _4, ...		std::bind表达式中 未绑定参数的占位符1.2.Classes				function				用指定的函数调用签名包装任何类型的可调用对象 mem_fn				    根据指向成员的指针创建函数对象 bad_function_call       调用空的std :: function 时引发的异常is_bind_expression	    指示对象是std::bind表达式或可用作 一个对象is_placeholder		    指示对象是标准占位符或可以用作一个 reference_wrapper	    CopyConstructible和CopyAssignable引用包装器 
1.3.Functions				bind_front				按顺序将可变数量的参数绑定到功能对象 (C++20)				bind				    将一个或多个参数绑定到功能对象 ref/cref			    创建一个std :: reference_wrapper,其类型由其自变量推导 invoke				    使用给定参数 调用任何Callable对象 
1.4.Function Objects				//算术运算	plus				    实现x + y函数对象minus				    实现x - y函数对象multiplies			    实现x * y函数对象divides				    实现x / y的 功能对象modulus			        实现x % y函数对象negate				    函数对象执行- X //比较	C++20支持ranges::equal_to		        实现x == y函数对象  not_equal_to		    实现x函数对象!=ygreater				    实现x > y函数对象less				    实现x < y函数对象greater_equal		    实现x > = y函数对象less_equal			    实现x <= y函数对象//逻辑运算	logical_and			    实现x && y函数对象logical_or			    实现x ||函数对象 ylogical_not			    函数对象实现!x //按位运算	bit_and				    实现x & y函数对象bit_or				    实现函数对象x|ybit_xor			    	实现x ^ y函数对象bit_not				    实现〜x函数对象Negators			    否定者	not_fn				    创建函数对象返回其持有的函数对象的结果的补码//Searchers搜索	default_searcher				标准C ++库搜索算法实现boyer_moore_searcher			Boyer-Moore搜索算法的实现boyer_moore_horspool_searcher	Boyer-Moore-Horspool搜索算法的实现

第二部分:function  多态的函数对象包装器

1.1.原型:std::functiontemplate< class R, class... Args >class function<R(Args...)>参数:R是返回值类型(若无则必为void)Args是函数的参数类型(若无必须包含空参数列表)1.2.说明:1)类模板std::function是通用多态函数包装器,可将各种可调用实体进行封装统一2)function实例可对任何可调用实体进行存储、复制、和调用操作所存储的可调用对象被称为目标的std::function3)function对象对可调用实体的一种类型安全的包裹(像函数指针这类可调用实体是类型不安全)可调用实体(普通函数,Lambda,函数指针,类成员函数,静态成员函数,仿函数(重载括号) )绑定表达式,成员函数指针和指向数据成员的指针		4)对于任何参数类型和返回值类型可以使用引用类型和const限定符std::function<>无参数时(不包含目标称为empty)引发std::bad_function_call1.3.备注:1)函数指针类型与函数对象或lambda闭包类型不同,前者是指针,后者是类以前用函数指针来完成的现在可用更安全的function来完成;function实现了一套类型消除机制,可以统一处理不同的函数对象类型2)要编写能用于任何的回调(函数指针,函数对象,lambda闭包)代码能够使用auto或模板类型参数只要能被调用,且其参数能与包装器兼容的都称之为多态函数对象包装器3)使用模板也有开销。为应对这种场景functional头文件定义std::function<>模板使用function<>类型的对象可以存储复制移动和调用任何类似函数的实体4)std::function<>本身是一函数对象,他可以封装其他任何类型的头等函数对于可赋值给指定function<>的类似函数实体,只有一种限制,他们必须有匹配的返回类型和参数类型。在尖括号中指定
1.4.	Member functions:					(constructor)			    构造函数							(destructor)			    析构函数 						operator=									swap				        交换内容					operator bool			    检查是否包含有效目标					operator()				    调用目标	//Target access目标访问		target_type				    获取存储目标的typeid					target				        获取指向存储目标的指针	//Non-member functions:					std::swap(std::function)	
1.5.提示:1)std::function<bool(int,int)>类型变量能够存储头等函数(int,int)也可存储任何能够用两个int实参调用函数。之间有一细微区别后者签名为(const int&,const int&),(long,long),甚至(double,double)函数可以接受2)类似返回类型并非必是bool,只要返回值能够转换为布尔值即可因此返回int,double*甚至std::unique_ptr<string>函数也可接受1.6.用途:function对可调用实体封装形成新可调用对象;不再纠结那么多的可调用实体。一切变简单function对象最大用处就是在实现函数回调1.7.验证函数是否可调用:function<>(通过隐式的强制转换运算符)被隐式转换为布尔值也可将其与nullptr做比较(虽然一般来说functon<>不需要包含指针)1.8.使用:std::function<void()> f1;std::function<int (int , int)> f2;1.9.Notes					如std::function从lambda表达式初始化其结果类型是引用的结果而没有尾随返回类型,应小心由于自动推论的工作方式,此类lambda表达式将始终返回prvalue。因此,生成的引用通常将绑定到一个临时对象,该临时对象的生命周期在std::function::operator()返回时结束		std::function<const int&()> F([]{ return 42; });					int x = F(); // 未定义的行为:F()的结果是一个悬空的引用	
实例1:
#include <iostream>
#include <functional>
#include <cmath>         
#include<cassert>using namespace std;bool Less(int x, int y) { return x < y; }struct A {A(int x) : x(x) {}void print_x(int x) const { std::cout << this->x + x << '\n'; }int x;
};void view_data(int x){std::cout << x << '\n';}//仿函数(functor)
struct Add {int operator()(int x,int y) const{return x + y;}};class B {
public:int get_x(int x) { return x; }            // 1.类成员函数static int static_get_x(int x) { return x; }   // 2.类静态函数
};
int main() {//存储一个自由函数:std::function<bool(int, int)> compare=Less; // 将函数指针存储到compareassert(compare(1, 2) == true);// 使用函数对象:compare = std::greater<>{};                 // 将函数对象存储到compareassert(compare(1, 2) == false);// 将lambda闭包存储为compareint n{ 10 };compare = [n](int x, int y) { return std::abs(x - n) < std::abs(y - n); };assert(compare(1, 2) == false);// 将调用的结果存储到std:bind					std::function<void()> f_view_data = std::bind(view_data, 3);f_view_data();//3// 存储对成员函数的调用					std::function<void(const A&, int)> f_print_x = &A::print_x;const A a(10);f_print_x(a, 1);//11f_print_x(10, 1);//11// store a call to a data member accessor					std::function<int(A const&)> f_num = &A::x;std::cout << "x: " << f_num(a) << '\n';// 存储对数据成员访问器的调用					using std::placeholders::_1;std::function<void(int)> f_print_x1 = std::bind(&A::print_x, a, _1);f_print_x1(2);// 存储对成员函数和对象PTR的调用					std::function<void(int)> f_print_x2 = std::bind(&A::print_x, &a, _1);f_print_x2(3);// 存储函数对象					std::function<int(int,int)> f_Add = Add();assert(f_Add(1, 2) == 3);//f_Add(18);//类普通成员函数比较特殊,需要使用bind函数,并且需要实例化对象,成员函数要加取地址符std::function< int(int)> func; B obj;// 类成员函数func = std::bind(&B::get_x, obj, std::placeholders::_1);assert(func(3) == 3);//类成员函数func = B::static_get_x;        // 类静态函数assert(func(3) == 3);// 检查是否是一个function<> 对象-否绑定到实际函数std::function<void(int&&)> empty;if (!empty)                                              // 等价empty != nullptrstd::cout << "不可调用对象" << std::endl;
}
实例2:#include <iostream>#include <functional>using namespace std;auto sub(long x, long y) { return x - y; }struct Sub {short operator()(short x, short y) { return x- y; } };int main() {std::function<int(int, int)> func;// 建立包裝器std::plus<int> add;         // 'plus' 被声明 'template<class T> T plus( T, T ) ;'因此 'add' 的类型是 'int add( int x, int y )'func = add;                     // 可行。'add' 的型参和回返值类型与 'func' 相符int a = func(1, 2);           // 注意: 若包裝器 'func' 沒有引用到任何函数抛出 'std::bad_function_call' 异常cout << a << endl;std::function<short(short, short)> func2;if (!func2) {                    // 因为还给'func2'赋值,此表达式为真func2 = &sub;              // 可行。'adjacent' 的型参和回返值类型可通过类型转换与'func2'相符cout << func2(1, 2) << endl;Sub obj;func = std::ref(obj);    // 模板类 'std::ref' 返回一个struct 'obj' 成员函数 'operator()' 的包裝cout << func(1, 2) << endl;}func = func2;              // 可行。'func2'的型参和回返值类型可通过类型转换而与'func' 相符cout << func(1, 2) << endl;}				

 第三部分:其他函数类测试

#include <iostream>
#include <string>
#include<vector>
#include <list>
#include<functional>
#include<algorithm>
#include <type_traits>
#include<cassert>using namespace std;int add(int x, int y) { return x + y; }
int sub(int x, int y){return x - y; }template<typename Rst>
void print(const vector<Rst>& vec)
{   if (is_same<bool, Rst>::value == true)cout << std::boolalpha;cout << endl << "[";for (auto vec : vec)cout << vec << ",";cout <<"]"<< endl;
}

函数对象测试: 

using vecInt = std::vector<int>;template<typename Rst,typename T>
void foo(const vecInt& v1,std::function<Rst(T)> const& fn) {vector<Rst> v3;std::transform(v1.begin(), v1.end(),std::back_inserter(v3),fn);print(v3);
}template<typename Rst, typename T>
void foo(const vecInt& v1, const vecInt& v2, std::function<int(int, int)> const& fn) {vector<Rst> v3;std::transform(begin(v1), end(v1), begin(v2), std::back_inserter(v3), fn);print(v3);
}
void test_FunctionObject(const vecInt& v1, const vecInt& v2) {std::vector<int>v3;foo<int, int>(v1, std::negate<int>());          //v3=-v1;  [-1, -2, -3, -4, -5, ]std::function< int(int, int)> fn = add;foo<int, int>(v1, v2, fn);                      //v3=v1+v2foo<int, int>(v1, v2, add);                     //v3=v1+v2foo<int, int>(v1, v2, std::plus<int>());        //v3=v1+v2  [6, 6, 6, 6, 6, ]foo<bool, int>(v1, v2, std::equal_to<int>());   //v1==v2 [false, false, true, false, false, ]foo<bool, int>(v1, v2, std::logical_and<int>());//v1 and v2 [true, true, true, true, true, ]foo<int, int>(v1, v2, std::bit_and<int>());     //bit and [1, 0, 3, 0, 1, ]
}

 测试占位符:

struct My_2 {} my_2;namespace std {template<>//自定义占位符struct is_placeholder<My_2> : public integral_constant<int, 2> {};
}//测试占位符:占位符主要用于函数std::bind的参数
void test_is_placeholder()
{std::cout << "标准占位符_5为参数编号= "<< std::is_placeholder<decltype(std::placeholders::_5)>::value<< '\n';auto b = std::bind(add, my_2, 2);std::cout << "使用自定义占位符选择添加2到11 add= "<< b(10, 11) // 第一个参数10被忽略<< '\n';
}

//测试reference_wrapper:
//通常用作将引用存储在标准容器中,容器通常无法直接保存引用 

void test_reference_wrapper()
{std::list<int> lst({1,2,3,4,5,6});std::vector<std::reference_wrapper<int>> vec(lst.begin(), lst.end());for (int v: lst) cout << v << ',';//1, 2, 3, 4, 5, 6,cout << endl;for (int i : vec) std::cout << i << ',';//1, 2, 3, 4, 5, 6,std::cout <<'\n';for (int& i : lst) i *= 2;for (int i : vec) std::cout << i << ',';//2, 4, 6, 8, 10, 12,
}

测试is_bind_expression: 

//指示对象是std::bind表达式或可用作一个对象
struct MyBind {typedef int result_type;int operator()(int a, int b) const { return a - b; }
};namespace std {template<>struct is_bind_expression<MyBind> : public true_type {};
}void test_is_bind_expression()
{// as if bind(f, bind(MyBind(), _1, _2), 2)auto foo = std::bind(add, MyBind(), 10);std::cout << "foo()=" << foo(1, 2) << '\n';//=(1-2)+10
}

测试:调用空的std :: function 时引发的异常 

void test_bad_function_call()
{std::function<int()> f = nullptr;try {f();}catch (const std::bad_function_call& e) {std::cout << e.what() << '\n';}
}

测试:std::mem_fn根据指向成员的指针创建函数对象 

struct A {void foo() {std::cout << "foo().\n";}void bar(int i) {std::cout << "bar()=" << i << '\n';}int x = 7;
};void test_mem_fn() {A a;auto foo_A = std::mem_fn(&A::foo);foo_A(a);auto bar_A = std::mem_fn(&A::bar);bar_A(a, 42);auto x_A = std::mem_fn(&A::x);assert(x_A(a) == 7);
}

创建一个std :: reference_wrapper,其类型由其自变量推导 

void f(int& n1, int& n2, const int& n3)
{std::cout << "In function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';++n1;    // increments the copy of n1 stored in the function object++n2;    // increments the main()'s n2// ++n3; // compile error
}//创建一个std :: reference_wrapper,其类型由其自变量推导
void test_ref()
{int n1 = 1, n2 = 2, n3 = 3;std::function<void()> bound_f = std::bind(f, n1, std::ref(n2), std::cref(n3));n1 = 10;n2 = 11;n3 = 12;std::cout << "Before function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';bound_f();std::cout << "After function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
}
/*
Output:Before function : 10 11 12
In function : 1 11 12
After function : 10 12 12
*/

使用给定参数 调用任何Callable对象 

struct B1 {B1(int x) : x(x) {}void print_add(int x) const { std::cout << this->x + x << '\n'; }int x;
};struct B2 {void operator()(int x) const{std::cout << x << '\n';}};void test_invoke(){auto print = [](int x) {std::cout << x << '\n'; };std::invoke(print, 1);//调用自由函数 =1std::invoke([=]() { print(2); });//调用lambda函数 =2const B1 foo(2);std::invoke(&B1::print_add, foo, 1);调用成员函数 =3// 调用(访问)数据成员std::cout << std::invoke(&B1::x, foo)+2 << '\n';//=4std::invoke(B2(), 5);//调用函数对象=5
}
int main(){std::vector<int>v1{ 1,2,3,4,5 };std::vector<int>v2{ 5,4,3,2,1 };std::vector<int>v3;test_FunctionObject(v1,v2);test_is_placeholder();test_reference_wrapper();test_is_bind_expression();test_bad_function_call();test_mem_fn();test_ref();test_invoke();
}

 

这篇关于C++20 functional (tcy)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/828931

相关文章

深入理解C++ 空类大小

《深入理解C++空类大小》本文主要介绍了C++空类大小,规定空类大小为1字节,主要是为了保证对象的唯一性和可区分性,满足数组元素地址连续的要求,下面就来了解一下... 目录1. 保证对象的唯一性和可区分性2. 满足数组元素地址连续的要求3. 与C++的对象模型和内存管理机制相适配查看类对象内存在C++中,规

在 VSCode 中配置 C++ 开发环境的详细教程

《在VSCode中配置C++开发环境的详细教程》本文详细介绍了如何在VisualStudioCode(VSCode)中配置C++开发环境,包括安装必要的工具、配置编译器、设置调试环境等步骤,通... 目录如何在 VSCode 中配置 C++ 开发环境:详细教程1. 什么是 VSCode?2. 安装 VSCo

C++11的函数包装器std::function使用示例

《C++11的函数包装器std::function使用示例》C++11引入的std::function是最常用的函数包装器,它可以存储任何可调用对象并提供统一的调用接口,以下是关于函数包装器的详细讲解... 目录一、std::function 的基本用法1. 基本语法二、如何使用 std::function

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<

C++包装器

包装器 在 C++ 中,“包装器”通常指的是一种设计模式或编程技巧,用于封装其他代码或对象,使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍,可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型: 1. 函数包装器 函数包装器用于封装一个或多个函数,使其接口更统一或更便于调用。例如,std::function 是一个通用的函数包装器,它可以存储任意可调用对象(函数、函数

C++11第三弹:lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页: 南桥几晴秋 🌈C++专栏: 南桥谈C++ 🌈C语言专栏: C语言学习系列 🌈Linux学习专栏: 南桥谈Linux 🌈数据结构学习专栏: 数据结构杂谈 🌈数据库学习专栏: 南桥谈MySQL 🌈Qt学习专栏: 南桥谈Qt 🌈菜鸡代码练习: 练习随想记录 🌈git学习: 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获:包含零个或者多个捕获符的逗号分隔列表 模板形参:用于泛型lambda提供个模板形参的名

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

系统架构师考试学习笔记第三篇——架构设计高级知识(20)通信系统架构设计理论与实践

本章知识考点:         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识