C++11 function类模板

std::function

---

1. std::function 简介
类模板std :: function是一个通用的多态函数包装器。 std :: function的实例可以存储，复制和调用任何可调用的目标 ：包括函数，lambda表达式，绑定表达式或其他函数对象，以及指向成员函数和指向数据成员的指针。当std::function对象未包裹任何实际的可调用元素，调用该std::function对象将抛出std::bad_function_call异常。

2. function类模板

  template< class R, class... Args >
  class function<R(Args...)>;

模板参数说明：

• R: 被调用函数的返回类型
• Args…：被调用函数的形参

例如：function<int(int,int)> func;
则 function类的实例func可以指向 返回值为int型，有两个形参都为int型的函数。

#include <functional>
#include <iostream>
int f(int a, int b)
{
  return a+b;
}
int main()
{
	std::function<int(int, int)>func = f;
	cout<<f(1, 2)<<endl;      // 3
	system("pause");
	return 0;
}

我们再来先来看看以前C和C++98的用法：

#include<iostream>
using namespace std;

// c type global function
int c_func(int a, int b)
{
    return a + b;
}

//function object
struct functor
{
public:
    int operator() (int a, int b)
    {
        return a + b;
    }
};
int main()
{
   typedef int (*Func)(int ,int);
   Func func = c_func;
   cout<< func(1,2)<<endl;  //3
   
   functor ft;
   cout<<ft(1,2)<<endl;    //3
   return 0;
}

从上面我们可以看出，使用C++11的function类调用函数方便多了。

虽然是function是类模板，但其只有成员函数，无数据成员。
3. function的成员函数

成员函数声明	说明
constructor	构造函数：constructs a new std::function instance
destructor	析构函数： destroys a std::function instance
operator=	给定义的function对象赋值
operator bool	检查定义的function对象是否包含一个有效的对象
operator()	调用一个对象

4. std::function用法详解

1. 调用普通函数

    #include <functional>
    #include <iostream>
     int f(int a, int b)
     {
       return a+b;
     }
     int main()
     {
     	std::function<int(int, int)>func = f;
     	cout<<func(1, 2)<<endl;      // 3
     	system("pause");
     	return 0;
     }

2. 调用函数对象

#include<iostream>
using namespace std;

//function object
struct functor
{
public:
    int operator() (int a, int b)
    {
        return a + b;
    }
};
int main()
{
   functor ft;
   function<int(int,int)> func = ft();
   cout<<func(1,2)<<endl;    //3
   return 0;
}

3. 调用模板函数对象

#include<iostream>
using namespace std;

//function object
template<class T>
struct functor
{
public:
    T operator() (T a, T b)
    {
        return a + b;
    }
};
int main()
{
   functor ft;
   function<int(int,int)> func = ft<int>();
   cout<<func(1,2)<<endl;    //3
   return 0;
}

4. 调用lambda表达式

#include <functional>
#include <iostream>
using namespace std;
int main()
{
	auto f = [](const int a, const int b) {return a + b; };
	std::function<int(int, int)>func = f;
	cout << func(1, 2) << endl;      // 3
	system("pause");
	return 0;
}

5. 调用类静态成员函数

#include <iostream>
#include <functional>
using namespace std;

class Plus
{
public:
    static int plus(int a, int b)
    {
        return a + b;
    }
};

int main()
{
    function<int(int, int)> f = &Plus::plus;
    cout << f(1, 2) << endl;     //3
    system("pause");                                       
    return 0;
}

6.调用类成员函数

#include <iostream>
#include <functional>
using namespace std;

class Plus
{
public:
    int plus(int a, int b)
    {
        return a + b;
    }
};

int main()
{
  Plus p;
    function<int(Plus&,int, int)> f = &Plus::plus;
  //function<int(const Plus,int, int)> f = &Plus::plus;
    cout << f(p,1, 2) << endl;     //3
    system("pause");                                       
    return 0;
}

7.调用类公有数据成员

#include <iostream>
#include <functional>
using namespace std;

class Plus
{
    Plus(int num_):num(num_){}
	public:
	    int plus(int a, int b)
	    {
	        return a + b;
	    }
	   int  num;
};

int main()
{
    const Plus p(2);
    function<int(const Plus&)> f = &Plus::num;
  //function<int(const Plus)> f = &Plus::num;
    cout << f(p) << endl;     //2
    system("pause");                                       
    return 0;
}

8.通过bind函数调用类成员函数

#include <iostream>
#include <functional>
using namespace std;

class Plus
{
public:
    int plus(int a, int b)
    {
        return a + b;
    }
};

int main()
{
   Plus p;
   // 指针形式调用成员函数
   function<int(int, int)> f = bind(&Plus::plus, &p, placeholders::_1, placeholders::_2);// placeholders::_1是占位符
   // 对象形式调用成员函数
   function<int(int, int)> f1 = bind(&Plus::plus, p, placeholders::_1, placeholders::_2);// placeholders::_1是占位符
   cout << f(1, 2) << endl;     //3
   cout << f1(1, 2) << endl;     //3
   system("pause");                                       
   return 0;
}

最后附上一段代码：

#include <iostream>
#include <map>
#include <functional>
using namespace std;
 
// 普通函数
int add(int i, int j) { return i + j; }
// lambda表达式
auto mod = [](int i, int j){return i % j; };
// 函数对象类
struct divide
{
	int operator() (int denominator, int divisor)
	{
		return denominator / divisor;
	}
};
 
///SubMain//
int main()
{
	map<char, function<int(int, int)>> binops = 
	{
		{ '+', add },
		{ '-', [](int i, int j){return i - j; } },
		{ '/', divide() }
	};
	cout << binops['+'](10, 5) << endl;
	cout << binops['-'](10, 5) << endl;
	cout << binops['/'](10, 5) << endl;
	system("pause");
	return 0;
}

参考：

• https://en.cppreference.com/w/cpp/utility/functional/function
• primer C++ 第五版
• http://www.cnblogs.com/xzlq/p/9505049.html
• https://blog.csdn.net/xf_zhen/article/details/52224139