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

相关文章

VSCode中C/C++编码乱码问题的两种解决方法

《VSCode中C/C++编码乱码问题的两种解决方法》在中国地区,Windows系统中的cmd和PowerShell默认编码是GBK,但VSCode默认使用UTF-8编码,这种编码不一致会导致在VSC... 目录问题方法一:通过 Code Runner 插件调整编码配置步骤方法二:在 PowerShell

C/C++随机数生成的五种方法

《C/C++随机数生成的五种方法》C++作为一种古老的编程语言,其随机数生成的方法已经经历了多次的变革,早期的C++版本使用的是rand()函数和RAND_MAX常量,这种方法虽然简单,但并不总是提供... 目录C/C++ 随机数生成方法1. 使用 rand() 和 srand()2. 使用 <random

Win32下C++实现快速获取硬盘分区信息

《Win32下C++实现快速获取硬盘分区信息》这篇文章主要为大家详细介绍了Win32下C++如何实现快速获取硬盘分区信息,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 实现代码CDiskDriveUtils.h#pragma once #include <wtypesbase

C++ Primer 标准库vector示例详解

《C++Primer标准库vector示例详解》该文章主要介绍了C++标准库中的vector类型,包括其定义、初始化、成员函数以及常见操作,文章详细解释了如何使用vector来存储和操作对象集合,... 目录3.3标准库Vector定义和初始化vector对象通列表初始化vector对象创建指定数量的元素值

C++实现回文串判断的两种高效方法

《C++实现回文串判断的两种高效方法》文章介绍了两种判断回文串的方法:解法一通过创建新字符串来处理,解法二在原字符串上直接筛选判断,两种方法都使用了双指针法,文中通过代码示例讲解的非常详细,需要的朋友... 目录一、问题描述示例二、解法一:将字母数字连接到新的 string思路代码实现代码解释复杂度分析三、

C++一个数组赋值给另一个数组方式

《C++一个数组赋值给另一个数组方式》文章介绍了三种在C++中将一个数组赋值给另一个数组的方法:使用循环逐个元素赋值、使用标准库函数std::copy或std::memcpy以及使用标准库容器,每种方... 目录C++一个数组赋值给另一个数组循环遍历赋值使用标准库中的函数 std::copy 或 std::

C++使用栈实现括号匹配的代码详解

《C++使用栈实现括号匹配的代码详解》在编程中,括号匹配是一个常见问题,尤其是在处理数学表达式、编译器解析等任务时,栈是一种非常适合处理此类问题的数据结构,能够精确地管理括号的匹配问题,本文将通过C+... 目录引言问题描述代码讲解代码解析栈的状态表示测试总结引言在编程中,括号匹配是一个常见问题,尤其是在

使用C++实现链表元素的反转

《使用C++实现链表元素的反转》反转链表是链表操作中一个经典的问题,也是面试中常见的考题,本文将从思路到实现一步步地讲解如何实现链表的反转,帮助初学者理解这一操作,我们将使用C++代码演示具体实现,同... 目录问题定义思路分析代码实现带头节点的链表代码讲解其他实现方式时间和空间复杂度分析总结问题定义给定

C++初始化数组的几种常见方法(简单易懂)

《C++初始化数组的几种常见方法(简单易懂)》本文介绍了C++中数组的初始化方法,包括一维数组和二维数组的初始化,以及用new动态初始化数组,在C++11及以上版本中,还提供了使用std::array... 目录1、初始化一维数组1.1、使用列表初始化(推荐方式)1.2、初始化部分列表1.3、使用std::

C++ Primer 多维数组的使用

《C++Primer多维数组的使用》本文主要介绍了多维数组在C++语言中的定义、初始化、下标引用以及使用范围for语句处理多维数组的方法,具有一定的参考价值,感兴趣的可以了解一下... 目录多维数组多维数组的初始化多维数组的下标引用使用范围for语句处理多维数组指针和多维数组多维数组严格来说,C++语言没