本文主要是介绍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 = ⊂ // 可行。'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)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
