C++函数对象包装器function类详解

函数对象包装器是对函数的封装，为函数对象提供一个容器，一个封装。C++中现有的可调用实体的一种类型安全的包装（相对来说，函数指针的调用不是类型安全的），换句话说，函数对象包装器就是函数的容器。

当我们有了函数的容器之后便能够更加方便的将函数、函数指针作为对象进行处理。直接调用函数包装器，传值，就可以调用函数。

函数对象包装器支持4种函数的封装

1.普通函数

2.匿名函数

3.类的成员函数

4.仿函数（重载了运算符的函数）

=========================================

1.普通函数的对象包装器

include "stdafx.h"
#include <algorithm>
#include <iostream>
#include <vector>
#include <funtional>using namespace std;int printf1(int value1,int value2)
{int ret = value1+value2;printf("普通函数的类对象包装器");printf("ret = %d",ret);return value;
}int main()
{printf1(3,5);std::function<int(int)> function1 = printf1;function1(3,6);return 0;}

===============================================================

2.匿名函数的对象包装器

Lambda的本质是一个特殊的，匿名的类类型。它是一个带有operator（）的类，即仿函数。仿函数opratoer就是使一个类的使用看上去像一个函数，其实现就是类中实现一个operator(),这个类有了类似函数的行为，就是一个仿函数类了。

仿函数是一个重载了 operator() 运算符、能行使函数功能的类，这个类也称为函数对象类，这个类的对象就是函数对象。函数对象本质上是一个对象，但其使用形式看起来和函数调用一样

Lambda表达式具体形式如下:

[capture](parameters)->return-type{body}

最简单的匿名函数是[](){}，它没有参数也没有返回值。在匿名函数中，[]里面用来捕获函数外部的变量，而()里面就是匿名函数的参数，{}里面就是函数的执行代码。

auto + 名字 =[]()->返回值{};
具体介绍：
1.[ ] 中括号表示函数对象的构造函数中是否接收外部变量。 [&] 表示使用引用的方式获取外部变量 [=] 表示使用值的拷贝的方式获取外部变量。2.() 这个小括号是就函数对象中的小括号符后面的参数列表。3.->返回值，需要就放，不需要就不放。根据自己需要，任君选择。4.{...} 就是函数对象的小括号运算符的函数体。

Lambda表达式实现例子

class Addnum{public:AddNum(int x):num_(num){};//int addNum(int x) const {//return num_ + x ;//}int operator(){int x} const{return num_ + x;}
}int main()
{//operatorauto add_num = AddNum(10);//auto x = add_num.addNum(5);auto x = add_num(5);std::cout<<"x:"<<x<<std::endl;//lambda//替代掉Addnum类auto add_num2 = [lamada_num =10](int x){return lamada_num +10};auto lamada_x = add_num_2(5);std::cout<<"lamada x:"<<lamada_x <<std::endl;}

========================================================

lamada函数的对象包装器

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;int printf1(int value1,int value2)
{int ret = value1+value2;printf("普通函数的类对象包装器");printf("ret = %d",ret);return value;
}class Printf_source {
public:Printf_source() {}                   //构造函数/*****************************************//operator()仿函数替代了My_Printf_source函数int My_Printf_source(int n1,int n2) {int ret = n1+n2;printf("普通函数的类对象包装器");printf("ret = %d",ret);return ret;}*********************************************///仿函数 ———————————————————代替My_Printf_source函数int operator()(int n1，int n2) {int ret = n1+n2;printf("普通函数的类对象包装器");printf("ret = %d",ret);return ret;}};int main()
{//函数对象包装器://为了函数提供了一种容器（封装），存放在对象或者变量中	printf1(3,5);          //打印出8//普通函数的封装//<int >返回值；(int)参数列表；	std::function<int(int)> function1 = printf1;function1(3,6);         //打印出9//匿名函数function<int(int)>function2 = [](int n1，int n2)->int {int ret = value1+value2;printf("类对象包装器");printf("ret = %d",ret);return ret;};function2(7,8);       //打印出15return 0;}

========================================================

再看个下面的例子，将对象包装器做为参数传递的情况

#include <iostream>
#include<functional>	//提供function模板类//传统C函数
int c_function(int a, int b)
{return a + b;
}//函数对象
class Functor
{
public:int operator()(int a, int b){return a + b;}
};//用函数指针做参数
typedef int (*pfun)(int, int);//函数的第一个参数只能接收函数指针
void show1(pfun f, int a, int b)
{std::cout << f(a, b) << std::endl;
}//用function<...>做参数
//函数第一个参数可以接收任何返回值为int,参数为int,int的可调用类型
void show2(std::function<int(int, int)> f, int a, int b)
{std::cout << f(a, b) << std::endl;
}
int main()
{show1(c_function, 3, 6);		//输出9//show1(Functor(), 3, 3);		//编译错误，因为Functor()不能转换为函数指针show2(c_function, 3, 5);		//输出8show2(Functor(), 3, 3);			//输出6system("pause");
}

==================================================

对象包装器的赋值操作

成员函数指针是一种指向类的非静态成员函数的指针。它的类型声明需要加上类名

• 静态成员函数：取出静态成员函数的地址时，需要通过类名，但&不是必须的；
• 非静态成员函数：取出非静态成员函数的地址时，需要通过类名，但&是必须的。非静态成员函数的第一个参数是this指针（它是隐藏的），因此在包装时需要指明第一个形参的类型为类的类型。

#include <iostream>
#include<functional>//测试用函数
int Minus(int a, int b)
{return a - b;
}//测试用类
class A
{
public:int operator()(int a, int b){return a * b;}void show(int a, int b)//普通成员函数{std::cout << a << " " << b << std::endl;}static void staticshow(int a, int b)//静态成员函数{std::cout << a << " " << b << std::endl;}
};
int main()
{using namespace std::placeholders;A a;//（1）function<>赋值类成员函数//第一种方法// 非静态成员函数包含一个隐藏的this指针，所以形参需要多定义一个类型Astd::function<void(A&, int, int)> f1(&A::show);f1(a, 3, 6);	//输出：3  6//第二种方法// 非静态成员函数包含一个隐藏的this指针，所以形参需要多定义一个类型Astd::function<int(A, int, int)> f1 = &A::show;f1(A(), 3, 6);//*********************************************************************************//（2）function<>赋值类静态成员函数//第一种方法std::function<void(int, int)> f2(&A::staticshow);f2(6, 6);//输出：6  6//第二种方法std::function<int(int，int)> f2 = A::staticshow; //*********************************************************************************//（3）function<>赋值bind//如果函数有多个参数，可以绑定部分参数，其他的参数在调用的时候指定std::function<int(int)> f3 = std::bind(Minus, 10, _1);std::cout << f3(1) << std::endl;	//输出：9//*********************************************************************************//（4）function<>赋值Lambda表达式std::function<int(int, int)> f4 = [](int a, int b) {return a + b; };std::cout << f4(3, 9) << std::endl;	//输出：12//*********************************************************************************//（5）function<>赋值函数对象//第一种方法std::function<int(int, int)> f5 = A();std::cout << f5(6, 6) << std::endl;	//输出：36//第二种方法std::function<int(int, int)> f5 = a;std::cout << f5(6, 6) << std::endl;	//输出：36system("pause");}