C++函数包装模板function

 

需要：#include <functional> 

std::function是一个函数包装器模板，在c++11中，将function纳入标准库中，该函数包装器模板能包装任何类型的可调用元素

一个std::function类型对象实例可以包装下列这几种可调用元素类型：函数、函数指针、类成员函数指针或任意类型的函数对象（例如定义了operator()操作并拥有函数闭包）

当std::function对象未包裹任何实际的可调用元素，调用该std::function对象将抛出std::bad_function_call异常

格式：function<int(int,int)> func;

第一个int：函数返回值类型，(int,int):函数的形参类型

则 function类的实例func可以指向 返回值为int型，有两个形参都为int型的任何函数

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

function的成员函数

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

 

调用普通函数

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

调用函数对象( 非模板类型) 

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

struct functor
{
    int operator() (int a, int b)  //重载()运算符 
    {
        return a + b;
    }
};
int main()
{
   functor ft;  //结构体对象 
   function<int(int,int)> func = ft;   
   cout<<func(1,2)<<endl;   //调用对象的()运算符函数 
   return 0;
}

调用函数对象(模板类型) 

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

template <class T>
struct Minus
{
    T operator() (T i, T j)
    {
        return i - j;
    }
};

int main()
{
    //function<int(int, int)> f = Minus<int>;
    function<int(int, int)> f ;
    Minus<int> M;
    f=M;
    cout << f(1, 2) << endl;         
    return 1;
}

 

 

 

包装模板函数

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

template <class T>
T func(T i, T j)
{
    return i - j;
}

int main()
{
    function<int(int, int)> f = func<int>;  //包装函数指向模板函数 
    cout << f(1, 2) << endl;    
    return 0;
}

包装lambda表达式

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

auto func = [](int i, int j){ return i - j; };

int main()
{
    function<int(int, int)> f = func; //包装匿名函数
    cout << f(10, 20) << endl;   
    return 1;
}

包装类静态成员函数(非模板类型)

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

class A
{
public:
    static int func(int i, int j)
    {
        return i - j;
    }
};

int main()
{
    function<int(int, int)> f = &A::func;  //包装类的静态函数
    cout << f(10, 20) << endl;   
    return 1;
}

 

包装类静态成员函数(模板类型)

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

class A
{
public:
    template <class T>
    static T func(T i, T j)
    {
        return i - j;
    }
};

int main()
{
    function<int(int, int)> f = &A::func<int>; //包装类的静态成员(模板类型)
    cout << f(1, 2) << endl;  
    return 1;
}

 

包装类对象成员函数(非模板类型)

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

class A
{
public:
    int func(int i, int j)
    {
        return i - j;
    }
};

int main()
{
    A m;
    function<int(int, int)> f = bind(&A::func, &m, placeholders::_1, placeholders::_2);
    //
    //
    cout << f(10, 20) << endl;   
    return 1;
}

 

 

 

包装类对象成员函数(模板类型)

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

class A
{
public:
    template <class T>
    T func(T i, T j)
    {
        return i - j;
    }
};

int main()
{
    A m;
    function<int(int, int)> f = bind(&A::func<int>, &m, placeholders::_1, placeholders::_2);
    cout << f(10, 20) << endl;       
    return 1;
}