C/C++编程：std::function(函数包装器)

妖狐艹你老母 2023-02-21 12:27 19阅读 0赞

> 头文件：
> 
>     <functional>
> 
> 定义：
> 
>     template< class >
>     class function; /* 未定义 */                (C++11 起)
>     
>     template< class R, class... Args >
>     class function<R(Args...)>;           	(C++11 起)

C++11的类模板std::function是通用的多态函数封装器，它的实例能存储、复制以及调用任何**可调用**目标：函数、lambda表达式、bind表达式或者其他函数对象，还有指向成员函数指针和指向数据成员指针。换句话说，srd::function是函数的容器。

存储的**可调用对象**称为std::function的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出 std::bad\_function\_call 异常。

#include <iostream>
    #include <functional>
     
    int main()
    {
        
        std::function<int()> f = nullptr;
        try {
        
            f();
        } catch(const std::bad_function_call& e) {
        
            std::cout << e.what() << '\n';
        }
    }

![在这里插入图片描述][202104151708508.png]

std::function 满足**可复制构造** (CopyConstructible) 和**可复制赋值**(CopyAssignable) 。

# 成员类型 #

![在这里插入图片描述][20210415165322350.png]

# 成员函数 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][20210415165409912.png]

# 非成员函数 #

![在这里插入图片描述][20210415165420653.png]

# 辅助类 #

![在这里插入图片描述][20210415165433544.png]

# 推导指引(c++17起) #

![在这里插入图片描述][20210415165551288.png]

(1)为std::function提供\*\*类模板实参推导 (CTAD)\*\*以允许函数推导  
(2)此重载仅若 &F::operator() 在作为不求值运算数时为良构且 decltype(&F::operator()) 拥有形式`R(G::*)(A...)`（可选地有 cv 限定，可选地有 noexcept ， 可选地有左值引用限定）而 G 为类类型才参与重载决议。推导类型为 std::function<R(A…)> 。

注意：

*  这些推导指引所推导的类型可能在之后的标准版本中更改（特别是若在之后的版本中添加 noexcept 支持到 std::function 则这可能发生）

## 示例 ##

#include <functional>
    int func(double) {
         return 0; }
    int main() {
        
      std::function f{
        func}; // 指引 #1 推导 function<int(double)>
      int i = 5;
      std::function g = [&](double) {
         return i; }; // 指引 #2 推导 function<int(double)>
    }

# 示例 #

#include <iostream>
    #include <functional>
    int  main()
    {
        
        std::function <void(void)>fun2 = []() {
         printf("%s", "golamba" ); };
        fun2();
    }

![在这里插入图片描述][20210415175326949.png]

#include <iostream>
    #include <functional>
    
    void go()
    {
        
        printf("%s", "go");
    }
    
    int  main()
    {
        
        //std::function<返回值(参数)>函数指针 = 指向函数
        std::function <void(void)>fun1 = go;
        fun1();
    }

![在这里插入图片描述][20210415175026547.png]

#include <iostream>
    #include <functional>
    
    using namespace std;
    
    void print_num(int i)
    {
        
        printf("%d\n", i);
    }
    int main() {
        
        // 存储自由函数
        std::function<void(int)> f_display = print_num;
        f_display(-9);
    
        // 存储 lambda
        std::function<void()> f_display_42 = []() {
         print_num(42); };
        f_display_42();
    
        // 存储到 std::bind 调用的结果
        std::function<void()> f_display_31337 = std::bind(print_num, 31337);
        f_display_31337();
        return 0;
    }

![在这里插入图片描述][20210415170355340.png]

#include <iostream>
    #include <functional>
    
    int add(int a, int b)
    {
        
        return a + b;
    }
    using namespace std;
    int  main()
    {
        
        function <int(int, int)>fun3 = add;  //20
        cout << fun3(10, 10) << endl;
    
        function <int(int, int)>fun4 = [](int a, int b)->int {
        return a + b; };
        cout << fun4(10, 10) << endl;
    }

![在这里插入图片描述][20210415175439728.png]

## 成员函数 ##

#include <iostream>
    #include <functional>
    
    
    //使用成员函数()
    class C {
        
    public:
        void memfunc(int x, int y) const {
        printf("%d", x + y);};
    };
    
    int  main()
    {
        
        std::function<void(const C&, int, int)> mf;
        mf =  &C::memfunc;
        mf(C(), 42, 77);
    }

![在这里插入图片描述][20210415180159450.png]

#include <iostream>
    #include <functional>
    
    using namespace std;
    
    struct Foo {
        
        Foo(int num) : num_(num) {
        }
        void print_add(int i) const {
         printf("%d\n", i + num_); }
        int num_;
    };
    
    int main() {
        
        // 存储到成员函数的调用
        std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
        const Foo foo(314159);
        f_add_display(foo, 1);
        f_add_display(314159, 1);
    
        // 存储到数据成员访问器的调用
        std::function<int(Foo const&)> f_num = &Foo::num_;
        std::cout << "num_: " << f_num(foo) << '\n';
    
        // 存储到成员函数及对象的调用
        using std::placeholders::_1;
        std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
        f_add_display2(2);
    
        // 存储到成员函数和对象指针的调用
        std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
        f_add_display3(3);
        return 0;
    }

![在这里插入图片描述][20210415170659252.png]

## 函数对象 ##

#include <iostream>
    #include <functional>
    
    using namespace std;
    
    struct PrintNum{
        
        void operator()(int i) const {
        
            printf("%d\n", i);
        }
    };
    int main() {
        
        // 存储到函数对象的调用
        std::function<void(int)> f_display_obj = PrintNum();
        f_display_obj(18);
        return 0;
    }

![在这里插入图片描述][20210415170740958.png]

## 批量调用函数 ##

#include <iostream>
    #include <functional>
    #include <vector>
    
    using namespace std;
    void func(int x, int y){
        
        printf("%d ", x + y);
    };
    int  main()
    {
        
       //initialize collections of tasks
        std::vector<std::function<void(int, int)>> tasks;
        tasks.push_back(func);
        tasks.push_back([](int x, int y) {
        
            printf("%d, %d", x, y);
        });
    
        //call each task
        for(std::function<void(int, int)> f : tasks) {
        
            f(33, 66);
        }
    }

![在这里插入图片描述][2021041517595257.png]

# 总结 #

*  类std::function<>，声明于`<function>`，提供多态包装器，允许你把可调用对象（比如function、member function、function object、lambda等）当作最高级对象（也叫做函数包装器）
 *  函数包装器目的是为了把函数包装起来，原理是**函数指针**
 *  使用方法：std::function <返回值（函数参数）>函数指针 = 指向函数

[202104151708508.png]: https://img-blog.csdnimg.cn/202104151708508.png
[20210415165322350.png]: https://img-blog.csdnimg.cn/20210415165322350.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210415165351524.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg==,size_16,color_FFFFFF,t_70
[20210415165409912.png]: https://img-blog.csdnimg.cn/20210415165409912.png
[20210415165420653.png]: https://img-blog.csdnimg.cn/20210415165420653.png
[20210415165433544.png]: https://img-blog.csdnimg.cn/20210415165433544.png
[20210415165551288.png]: https://img-blog.csdnimg.cn/20210415165551288.png
[20210415175326949.png]: https://img-blog.csdnimg.cn/20210415175326949.png
[20210415175026547.png]: https://img-blog.csdnimg.cn/20210415175026547.png
[20210415170355340.png]: https://img-blog.csdnimg.cn/20210415170355340.png
[20210415175439728.png]: https://img-blog.csdnimg.cn/20210415175439728.png
[20210415180159450.png]: https://img-blog.csdnimg.cn/20210415180159450.png
[20210415170659252.png]: https://img-blog.csdnimg.cn/20210415170659252.png
[20210415170740958.png]: https://img-blog.csdnimg.cn/20210415170740958.png
[2021041517595257.png]: https://img-blog.csdnimg.cn/2021041517595257.png