C++ – 总结C++的可调用类型Callable

转载自：https://www.chuxin911.com/C++_callable_objects_summary_20211120/ ，如侵联删。

C++中有很多Callable类型，本文将介绍Callable 的基础概念, 典型的 Callable 类型，例如函数对象(狭义)，函数指针，lambda 匿名函数，函数适配器，std::function 仿函数等。

1 C++中的Callable类型

1.1 基础

（1）定义(参考)

可调用(Callable) 类型是可应用 INVOKE 操作(std::invoke 是在 C++17 里定义的类，感觉意思就是执行函数操作的模板类)

（2）要求

一个 T 类型要满足为 callable 需要以下表达式在不求值语境中良构。

INVOKE<R>(f, [std::declval]ArgTypes>()...) 即 INVOKE<R>(f, t1, t2, ..., tN)。

其中 f 为 T 类型的对象，ArgTypes 为适合的实参类型列表，R 为适合的返回类型。

R为 void 的时可以表示为 static_cast<void>(INVOKE(f, t1, t2, ..., tN))。

（3）详细

1. 若 f 是类 T 的成员函数指针: 上面等价于 (t1.*f)(t2, ..., tN) 或者 t1 是指针时 ((*t1).*f)(t2, ..., tN)
2. 若 N == 1 且 f 是类 T 的数据成员指针: INVOKE(f, t1) 等价于 t1.*f, 或者指针形式 (*t1).*f
3. 均不满足上面的情况表明 f 是一个函数对象(Function Object) : INVOKE(f, t1, t2, ..., tN) 等价于 f(t1, t2, ..., tN)

同时, 对于成员函数指针和数据成员指针，t1 可以是一个常规指针或一个重载了 operator* 的类的对象，例如智能指针 std::unique_ptr 或 std::shared_ptr。

1.2 可作为参数的标准库

下列标准库设施接受任何可调用(Callable)类型：

2 C++中一些典型的Callable类型

2.1 函数对象 Function Object

一个重载了括号操作符()的对象，也就是可以以f(args)形式进行函数调用的对象。

#include<iostream>
#include<cstdlib>
using namespace std;
class Add {
public:
    const int operator()(const int a,const int b){
        return a+b;}
};

int main() {
    Add addFunction; //函数对象
    cout<<addFunction(2, 3)<<endl;// 5 
    system("pause");
    return 0;
}

我的第一印象是它跟函数指针有什么区别？就像是个函数执行包装器, 一个对象型的函数指针?

但是函数对象本质上还是一个 class 的具体化 object，里面是可以附带一些成员变量(可以理解为函数对象的状态(state))的，这就让函数对象的应用场景比函数指针更广阔，最典型的便是 STL 了。C++ 的 STL 中的众多 algorithm，非常依赖于函数对象处理容器的元素。想按照 STL 算法里的要求实现其功能要提供一些函数对象作为参数，即谓词参数(predicate)。

例如对于 find_if 算法

class NoLess{
public:
    NoLess(int min = 0):m_min(min){}
    bool operator() (int value) const{
        return value >= m_min;}
private:
    int m_min;
};

find_if(dest.begin(),dest.end(),NoLess(10));  //dest容器里找是否存在不小于10的元素

对于普通函数来说，只要签名一致，其类型就是相同的，是类型不安全的。但是这并不适用于函数对象，因为函数对象的类型是其类的类型。这样，函数对象有自己的类型，这也意味着函数对象可以用于模板参数，这对泛型编程有很大提升。因为函数对象一般用于模板参数， 模板一般会在编译时会做一些优化。因此函数对象一般快于普通函数，类也可以在使用的时候动态再产生，节省成本。

既然是类，那就有它的限制，例如要注意，如同其他所有对象(狭义上的对象，我感觉内置类型其实也可以被叫对象，按场景区分吧)一样，如果 pass-by-value 的化，对象里的成员变量是被复制进去的，一旦对象被析构了，里面的成员变量也是无法保存下来的，所以可以 pass-by-reference/pointer，

函数指针并不是没有其用处了，对于 C API 库里的某些函数不支持函数对象还是有用武之地的，例如 <cstdlib> 里面的排序函数 qsort 只能调用函数指针。

void qsort( void *ptr, size_t count, size_t size,int (*comp)(const void *, const void *) );

2.2 函数

除了普通的函数，当然也包括类成员函数。
这里不提及模板函数，因为模板函数的概念只存在于编译期，运行期的函数没有模板的概念，都是经过完全特化过的，因此与普通函数/类成员函数的概念是一致的。

2.3 函数指针

#include<iostream>
#include<cstdlib>
using namespace std;
int AddFunc(int a, int b)  {  
    return a + b;}  

int main() {
    int (*Add1) (int a, int b); //函数指针,函数名两侧的()不可省略
    int (*Add2) (int a, int b);
    Add1 = &AddFunc;
    Add2 = AddFunc;       
    cout << (*Add1) (3, 2)<<endl; 
    cout<<Add1(3, 2)<<endl;       //输出可以加*,也可以不加
    system("pause");
    return 0;
}

2.4 Lambda 匿名函数

2.4.1 基本形式

声明

[capture list] (params list) mutable exception-> return type { function body }

各项具体含义如下：

1. capture list: 捕获外部变量列表
2. params list: 形参列表
3. mutable指示符: 用来说用是否可以修改捕获的变量, 因为lambda的() operator() 默认是 const 的
4. exception: 异常设定
5. return type: 返回类型, 允许省略 lambda 表达式的返回值定义
6. function body: 函数体

捕获形式

省略其中的某些成分来声明”不完整”的Lambda表达式：

2.4.2 一些关于Lambda表达式的细节

1. 按值捕获与按引用捕获的区别

int a = 0;
auto f = [=]{ return a; };      // 按值捕获外部变量
a += 1;                         // a被修改了
std::cout << f() << std::endl;  // 输出依旧为0,如果想要跟着被改变需要使用引用捕获

2. lambda 表达式转换成函数指针

没有捕获变量的 lambda 表达式可以直接转换为函数指针，而捕获变量的 lambda 表达式则不能转换为函数指针。

typedef void(*Ptr)(int*);
Ptr p = [](int* p){delete p;};  // 正确, 没有状态的 lambda (没有捕获)的lambda表达式可以直接转换为函数指针
Ptr p1 = [&](int* p){delete p;};  // 错误, 有状态的 lambda 不能直接转换为函数指针

3. Lambda嵌套

int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5); //16

4. 作为 STL 算法函数谓词参数

vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
sort(myvec.begin(), myvec.end(), [](int a, int b) -> bool { return a < b; });

2.4.3 C++14 中的 lambda 新特性

1. lambda 捕捉表达式/右值

// 利用表达式捕获,可以更灵活地处理作用域内的变量
int x = 4;
auto y = [&r = x, x = x + 1] { r += 2; return x * x; }();
// 此时 x 更新为6,y 为25

// 直接用字面值初始化变量
auto z = [str = "string"]{ return str; }();
// 此时z是const char* 类型,存储字符串 string

//不能复制只能移动的对象,可以用std::move初始化变量
auto myPi = std::make_unique<double>(3.1415);
auto circle_area = [pi = std::move(myPi)](double r) { return *pi * r * r; };
cout << circle_area(1.0) << endl; // 3.1415

2. 泛型 lambda 表达式

auto add = [](auto x, auto y) { return x + y; };//推断类型
int x = add(2, 3);   // 5
double y = add(2.5, 3.5);  // 6.0

2.5 函数适配器

将函数对象与其它函数对象，或者特定的值，或者特定的函数相互组合的产物。由于组合特性，函数适配器可以满足特定的需求，头文件 <functional> 定义了几种函数适配器：

• std::bind(op, args...): 将函数对象 op 的参数绑定到特定的值 args
• std::mem_fn(op): 将类的成员函数转化为一个函数对象
• std::not1(op), std::not2(op),std::unary_negate,std::binary_negate: 一元取反器和二元取反器

2.5.1 std::bind

这里的函数对象就包括了上面所有的类型, 当然也包含自己, 因此可以利用 std::bind 封装出很多有意思的功能。

1. 嵌套

// 定义一个接收一个参数,然后将参数加10再乘以2的函数对象
auto plus10times2 = std::bind(std::multiplies<int>{},
        std::bind(std::plus<int>{}, std::placeholders::_1, 10), 2);
cout << plus10times2(4) << endl; // 输出:  28 

// 定义3次方函数对象
auto pow3 = std::bind(std::multiplies<int>{},
        std::bind(std::multiplies<int>{}, std::placeholders::_1, std::placeholders::_1),
        std::placeholders::_1);
cout << pow3(3) << endl;  // 输出: 27

2. 调用类中的成员函数

class Person{
public:
    Person(const string& n) : name{ n } {}
    void print() const { cout << name << endl; }
    void print2(const string& prefix) { cout << prefix << name << endl; }
private:
    string name;
};
int main()
{
    vector<Person> p{ Person{"Tick"}, Person{"Trick"} };
    // 调用成员函数print
    std::for_each(p.begin(), p.end(), std::bind(&Person::print, std::placeholders::_1));
    // 此处的std::placeholders::_1表示要调用的Person对象,所以相当于调用arg1.print()
    // 输出: Tick   Trick
    std::for_each(p.begin(), p.end(), std::bind(&Person::print2, std::placeholders::_1,
        "Person: "));
    // 此处的std::placeholders::_1表示要调用的Person对象,所以相当于调用arg1.print2("Person: ")
    // 输出: Person: Tick   Person: Trick

    return 0;
}

3. 调用 lambda 表达式

vector<int> data{ 1, 2, 3, 4 };
auto func = std::bind([](const vector<int>& data) { cout << data.size() << endl; },
                        std::move(data));
func();  // 4
cout << data.size() << endl;  // 0

4. 调用范围内函数

char myToupper(char c){
    if (c >= 'a' && c <= 'z')
        return static_cast<char>(c - 'a' + 'A');
    return c;
}

int main()
{
    string s{ "Internationalization" };
    string sub{ "Nation" };
    auto pos = std::search(s.begin(), s.end(), sub.begin(), sub.end(),
                        std::bind(std::equal_to<char>{}, 
                            std::bind(myToupper, std::placeholders::_1),
                            std::bind(myToupper, std::placeholders::_2)));
    if (pos != s.end()){
        cout << sub << " is part of " << s << endl;
    }
    // 输出: Nation is part of Internationalization
    return 0;
}

5. 默认 pass-by-value, 如果想要 pass-by-reference, 需要用 std::ref 和 std::cref 包装.
   std::cref 比 std::ref 增加 const 属性

void f(int& n1, int& n2, const int& n3){
    cout << "In function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
    ++n1;
    ++n2;
    // ++n3;  //无法编译
}

int main()
{
    int n1 = 1, n2 = 2, n3 = 3;
    auto boundf = std::bind(f, n1, std::ref(n2), std::cref(n3));
    n1 = 10;
    n2 = 11;
    n3 = 12;
    cout << "Before function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
    boundf();
    cout << "After function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
    //  Before function : 10 11 12
    //  In function : 1 11 12
    //  After function : 10 12 12

    return 0;
}

2.5.2 std::mem_fn

与 std::bind 相比，std::mem_fn 的范围又要小一些，仅调用成员函数，并且可以省略掉用于调用对象的占位符。
因此使用 std::men_fn 不需要绑定参数，可以更方便地调用成员函数。

vector<Person> p{ Person{ "Tick" }, Person{ "Trick" } };
std::for_each(p.begin(), p.end(), std::mem_fn(&Person::print));
// 输出: Trick Trick
Person n{ "Bob" };
std::mem_fn(&Person::print2)(n, "Person: ");
// 输出: Person: Bob

std::mem_fn 还可以调用成员变量

class Foo{
public:
    int data = 7;
    void display_greeting() { cout << "Hello, world.\n"; }
    void display_number(int i) { cout << "number: " << i << '\n'; }

};
int main()
{
    Foo f;
    // 调用成员函数
    std::mem_fn(&Foo::display_greeting)(f);  // Hello, world.
    std::mem_fn(&Foo::display_number)(f, 20);  // number: 20
    // 调用数据成员
    cout << std::mem_fn(&Foo::data)(f) << endl;  // 7
    return 0;
}

2.5.3 std::not1, std::not2, std::unary_negate, std::binary_negate

std::not1, std::not2 分别构造一个与谓词结果相反的一元/二元函数对象。
std::unary_negate，std::binary_negate 分别返回其所保有的一元/二元谓词的逻辑补的包装函数对象，其对象一般为 std::not1，std::not2 构造的函数对象，即又加了一层包装。
下面分别是其使用示例：

//std::not1
#include <iostream>
#include <vector>
#include <functional>
int main(int argc, char **argv) 
{  
    std::vector<int> nums = {5, 3, 4, 9, 1, 7, 6, 2, 8};
    std::function<bool(int)> less_than_5 = [](int x){ return x <= 5; };
    // count numbers of integer that not less and equal than 5
    std::cout << std::count_if(nums.begin(), nums.end(), std::not1(less_than_5)) << "\n";
    //输出结果4
    return 0;
}

//std::not2
using namespace std;
int main(int argc, char **argv) 
{  
    std::vector<int> nums = {5, 3, 4, 9, 1, 7, 6, 2, 8};
    std::function<bool(int, int)> ascendingOrder = [](int a, int b) { return a<b; };
    // sort the nums in descending order: not ascending order
    std::sort(nums.begin(), nums.end(), std::not2(ascendingOrder));
    for(int i:nums) {
        std::cout << i << "\t";}
    //输出结果: 9   8   7   6   5   4   3   2   1  
    return 0;
}

//std::unary_negate
#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
struct less_than_7 : std::unary_function<int, bool>{
    bool operator()(int i) const { return i < 7; }
};

int main()
{
    std::vector<int> v;
    for (int i = 0; i < 10; ++i) v.push_back(i);
    std::unary_negate<less_than_7> not_less_than_7((less_than_7()));
    std::cout << std::count_if(v.begin(), v.end(), not_less_than_7);
    //输出8 9

}

//std::binary_negate
struct same : std::binary_function<int, int, bool>{
    bool operator()(int a, int b) const { return a == b; }
};

int main()
{
    std::vector<int> v1;
    std::vector<int> v2;
    for (int i = 0; i < 10; ++i) v1.push_back(i);
    for (int i = 0; i < 10; ++i) v2.push_back(10 - i);
    std::vector<bool> v3(v1.size());
    std::binary_negate<same> not_same((same()));
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), not_same);

    std::cout.setf(std::ios_base::boolalpha);
    for (int i = 0; i < 10; ++i)
        std::cout << v1[i] << ' ' << v2[i] << ' ' << v3[i] << ' ';
//输出:0 10 true 1 9 true 2 8 true 3 7 true 4 6 true 5 5 false 6 4 true 7 3 true 8 2 true 9 1 true
}

2.5.4 std::not_fn

注意 C++17 已经把上面的 std::not1，std::not2，std::unary_negate 和 std::binary_negate 抛弃，统一由 std::not_fn 替代。

//移除把满足谓词p的元素都copy到容器中
template <typename T, typename Pred>
auto FilterRemoveCopyIf(const std::vector<T>& vec, Pred p) {
    std::vector<T> out;
    std::remove_copy_if(begin(vec), end(vec), 
                        std::back_inserter(out), std::not_fn(p));
    return out;
}

2.6 std::function

五花八门的 Callable，个个都是人才，但是不好带(不好实现 generic programming)，所以一个把所有 callable 对象封装成统一形式的类型模板。
std::function 的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，实现一种类型安全的包裹。

2.6.1 基本形式

原型为

template< class R, class... Args > //R是返回值类型,Args是函数的参数类型
class function<R(Args...)>;

其存储的可调用对象被称为 std::function 的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出 std::bad_function_call 异常。

std::function 满足可复制构造 (Copy Constructible) 和可复制赋值 (Copy Assignable) (参考)。

代码例子如下：

#include <functional>
#include <iostream>

struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '\n'; }
    int num_;
};

void print_num(int i){
    std::cout << i << '\n';
}

struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};

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();

    // 存储到成员函数的调用
    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);

    // 存储到函数对象的调用
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);

    auto factorial = [](int n) {
        // 存储 lambda 对象以模拟"递归 lambda ",注意额外开销
        std::function<int(int)> fac = [&](int n){ return (n < 2) ? 1 : n*fac(n-1); };
        // note that "auto fac = [&](int n){...};" does not work in recursive calls
        return fac(n);
    };
    for (int i{5}; i != 8; ++i) { std::cout << i << "! = " << factorial(i) << ";  "; }
}

可能的输出

-9
42
31337
314160
314160
num_: 314159
314161
314162
18
5! = 120;  6! = 720;  7! = 5040;

2.6.2 回调函数

std::function 的应用之一：结合 typedef 定义函数类型构造回调函数。

typedef std::function<void(std::string)> CallBack;
Class MessageProcessor {
private:
    CallBack callback_;
public:
    MessageProcessor(Callback callback):callback_(callback){}
    void ProcessMessage(const std::string& msg) {
        callback_(msg);
    }
};

参考

• https://www.chuxin911.com/C++_callable_objects_summary_20211120/