C++#现代#003#函数对象（仿函数）

发表于： 更新于： 分类于：
字数： 1533 阅读：≈ 4分钟 浏览：

在C++11之前，要实现函数对象或者仿函数，主要参考《C++设计新思维》中的Loki库，它采用模板推导的方式来实现。虽然Loki可以模拟函数对象，但其代码看起来比较晦涩，使用又不方便。在C++11以后，开始原生支持函数对象，新标准中的用法简单清晰，所有的可调用对象有了统一的调用方式，极易上手。本文总结函数对象的各种使用方法。

std::function的定义 

1
2
3

#include <functional>
template< class R, class... Args >
class function<R(Args...)>; // R表示返回值，Args表示函数参数

类模板std::function是通用多态函数封装器。std::function的实例能存储、复制及调用任何可调用目标，包括函数、lambda表达式、bind表达式或其他函数对象，还有指向成员函数指针和指向数据成员指针。 存储的可调用对象被称为std::function的目标。若 std::function不含目标，则称它为空。调用空std::function的目标导致抛出std::bad_function_call异常。

std::bind绑定器

std::bind用来将可调用对象与其参数一起进行绑定，绑定后的结果可以使用std::function进行保存。在绑定参数时，可以直接绑定函数的全部参数，也可以绑定部分参数。在绑定部分参数时，通过使用std::placeholders，来决定该位置上的参数为调用发生时的第几个参数。 比如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 将本文件保存，例如文件名叫做function.cpp
// 编译：g++ -o test function.cpp -std=c++11
// 运行：./test
 
#include <functional>
#include <iostream>
 
void print_num(int i, int a)
{
    std::cout << i << "," << a << std::endl;
}
 
int main(int argc, char ** argv)
{
    // 示例1：绑定所有的两个参数
    // std::placeholders::_1 代表函数调用时的第一个参数
    // std::placeholders::_2 代表函数调用时的第二个参数
    std::function<void(int, int)> FuncA = std::bind(print_num, std::placeholders::_1, std::placeholders::_2);
 
    // 此时1对应std::placeholders::_1, 2对应std::placeholders::_2
    FuncA(1, 2);    // 执行后函数输出：1,2
 
    // 示例2：绑定部分参数
    // 我们默认print_num的第一个参数值始终为3，在实际调用时，仅需要传入第二个参数即可
    std::function<void(int, int)> FuncB = std::bind(print_num, 3, std::placeholders::_1);
 
    // 此时4对应std::palcehoders::_1
    FuncB(4,5); // 执行后函数输出：3,4，注意结果并不是4,5。因为在函数定义已经将3作为第一个参数的默认值。
     
    // 示例3：绑定部分函数
    std::function<void(int)> FuncC = std::bind(print_num, 3, std::placeholders::_1);
     
    FuncC(4);   // 执行后函数输出：3,4
 
    return 0;
}

std::function与std::bind示例 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107

// 将本文件保存，例如文件名叫做function.cpp
// 编译：g++ -o test function.cpp -std=c++11
// 运行：./test
 
#include <functional>
#include <iostream>
 
struct Foo 
{
    Foo(int num) : num_(num) {}
     
    void print_num(int i) const { std::cout << "num_:" << num_  << ", i:" << i << std::endl; }
 
    int num_;
};
 
struct PrintNum 
{
    void operator()(int i) const
    {
        std::cout << i << std::endl;
    }
     
    static void print_num(int i , int a)
    {
        std::cout << i << "," << a << std::endl;
    }
};
 
void print_num(int i)
{
    std::cout << i << std::endl;
}
 
void print_num2(int i, int a)
{
    std::cout << i << "," << a << std::endl;
}
 
template <int T_SIZE>
void print_num3(int i, int a)
{
    std::cout << i << "," << a << ", T_SIZE:" << T_SIZE << std::endl;
}
 
void print_num4()
{
    std::cout << "print_num4" << std::endl;
}
 
int main()
{
    // 示例1：存储自由函数
    std::function<void(int)> FuncFree1 = print_num;
    FuncFree1(101);
 
    std::function<void(int, int)> FuncFree2 = print_num2;
    FuncFree2(102, 1021);
 
    std::function<void(int, int)> FuncFree3 = print_num3<102333>;
    FuncFree3(103, 1031);
 
    std::function<void(int, int)> FuncFree4 = PrintNum::print_num;
    FuncFree4(104, 1041);
 
    std::function<void()> FuncFree5 = print_num4;
    FuncFree5();
 
    // 示例2：存储 lambda
    std::function<void()> FuncLambda1 = []() { print_num(201); };
    FuncLambda1();
 
    std::function<void(int)> FuncLambda2 = [](int iNum) { print_num(iNum); };
    FuncLambda2(202);
 
    // 示例3：存储到成员函数的调用
    std::function<void(const Foo&, int)> FuncFunc = &Foo::print_num;
 
    const Foo xFoo3(300);
    FuncFunc(xFoo3, 3011);
    FuncFunc(302, 3021);    // 由302构造一个Foo对象
 
    // 示例4：存储到数据成员访问器的调用
    Foo xFoo4(400);
    std::function<int(Foo const&)> FuncData = &Foo::num_;
    std::cout << "num_:" << FuncData(xFoo4) << std::endl;
 
    // 示例5：存储到std::bind调用的结果
    std::function<void()> FuncBind1 = std::bind(print_num, 501);
    FuncBind1();
  
    // 示例6：存储到成员函数及对象的调用
    Foo xFoo6(600);
 
    std::function<void(int)> FuncObject = std::bind(&Foo::print_num,  xFoo6, std::placeholders::_1);
    FuncObject(601);
 
    // 示例7：存储到成员函数和对象指针的调用
    Foo xFoo7(700);
 
    std::function<void(int)> FuncPointer = std::bind(&Foo::print_num, &xFoo7, std::placeholders::_1);
    FuncPointer(701);
 
    // 示例8：存储到函数对象的调用
    std::function<void(int)> FuncOperator = PrintNum();
    FuncOperator(801);
}

参考