c++11:可调用对象

文章目录

引言
1.普通函数
2.函数指针
3.函数对象(仿函数)
4.Lambda表达式(匿名函数)
5.function
6.bind

引言

可调用对象是C++11引入的新概念，可以像函数调用方式的触发调用的对象就是可调用对象。
c++98可调用对象(普通函数，函数指针，仿函数)
c++11可调用对象(普通函数，函数指针，仿函数，bind生成对象，lambda表达式，function对象)

1.普通函数

bool isEven(int value)
{return (0 == value%2)
}
vector<int> vec{2,5,9,10,11};
auto res = find_if(vec.begin(), vec.end(),isEven);
isEven 就是普通函数可调用对象

2.函数指针

函数指针就是指向普通函数的指针，一般可以理解为函数的引用，不同之处在于一个函数指针可以指向多个普通函数，
只要两者具有相同的函数签名格式(即相同的输入输出参数，返回值)

/*----------例一-------------------*/
void print_num(int num)
{cout<<"num="<<num;
}
int main()
{void (void*funPtr)(int) = &print_num;funPtr(666);//调用函数指针return 0;
}/*----------例二-------------------*/
bool isEven(int value)
{return (0 == value % 2);
}
//这是一个类型别名定义，EvenDecide被定义为一个函数指针类型，它可以接受一个整数参数并返回布尔值的函数
using EvenDecide = bool(*)(int value);std::vector<int> vec{ 2, 5, 9, 10, 11 };
//这行代码创建了一个函数指针变量eventDecie，并将函数isEven的地址赋值给它，这样，evenDecide就可以用来调用isEven函数
EvenDecide evenDecide = isEven;auto res = std::find_if(vec.begin(), vec.end(), evenDecide);

3.函数对象(仿函数)

重载操作符()的类 ，其对象常称为函数对象
函数对象使用重载的()时，行为类似函数调用，因此也叫仿函数

仿函数是一个类或结构体，它重载了调用运算符operator()。
通过重载这个运算符我们可以创建一个可调用的对象，就像函数一样使用它。
仿函数提供了一种将函数调用和面向对象编程结合起来的方式。
使用仿函数，我们可以将其作为参数传递给函数，算法或容器，并在需要的时候通过运算符来执行相应的操作，它们可以存储状态，实现自定义行为并具有更高的灵活性和可定制性。
使用：
函数对象可以像普通函数那样调用，可以有参数和返回值
函数对象的优点：
函数对象可以有自己的状态（即对象的成员变量）
函数对象可以作为参数传递

/*----------------例一-----------------*/
#include <iostream>
using namespace std;
struct MultiplyBy
{MultiplyBy(int fac) :factor(fac) {}int operator()(int num) {return num * factor;}int factor;
};int main()
{MultiplyBy multiby(10);cout<<"multiby(5)="<<multiby(5);//50return 0;
}/*----------------例二-----------------*/
class EvenJudge
{
public:bool operator() (int value){return (0 == value % 2);}
};std::vector<int> vec{ 2, 5, 9, 10, 11 };EvenJudge evenJudge;
// 1. 通过构造临时对象，调用operator()重载函数
auto res1 = std::find_if(vec.begin(), vec.end(), EvenJudge());
// 2. 通过对象，隐式调用调用operator()重载函数
auto res2 = std::find_if(vec.begin(), vec.end(), evenJudge);
// 3. 通过对象，显示调用operator()重载函数
auto res3 = std::find_if(vec.begin(), vec.end(), [&evenJudge](int value) {return evenJudge.operator()(value);
});

4.Lambda表达式(匿名函数)

是一种定义内联函数的方式，与普通函数不同，匿名函数不需要命名，可以直接在需要的地方定义和使用。
lambda表达式常用于编写简洁，简单的函数，并且可以轻松的捕获周围作用域中的变量。它们非常适用于需要一个简单，临时的回调函数或谓词的情况。

lambda表达式语法
[capture List]->return_type(parameters){body}
//因为lambda表达式会自动推导返回值类型，所以->return_type可以省略
int main()
{int x=5;int y=6;auto sum=[x,&y](){return x+y;}int result = sum();cout<<"Sum="<<result;return 0;
}/*----------------例二-------------------------*/
auto fnIsEven = [](int value) -> bool {return (0 == value % 2);
};auto res4 = std::find_if(vec.begin(), vec.end(), fnIsEven);
auto res5 = std::find_if(vec.begin(), vec.end(), [](int value) {return(0 == value % 2);
});

在上述示例中，Lambda 表达式 x, &y{ return x + y; } 捕获了变量 x（按值）和 y（按引用），并返回它们的和。通过调用 sum()，可以获取到捕获变量的求和结果。
匿名函数提供了一种更简洁、灵活的方式来编写内联函数，特别适合于需要临时使用的函数功能。

5.function

std::function是一个可调用对象包装器，是一个类模板，可以容纳除了类成员函数指针之外的所有可调用对象，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟它们的执行。

/*-------------例一-------------*/
#include <functional>
void myFunction(int x) {std::cout << "Value: " << x << std::endl;
}struct MyFunctor {void operator()(int x) const {std::cout << "Value: " << x << std::endl;}
};int main() {std::function<void(int)> func;// 包装函数指针func = &myFunction;func(42);// 包装仿函数对象MyFunctor myFunc;func = myFunc;func(42);return 0;
}/*-------------例二-------------*/
# include <iostream>
# include <functional>typedef std::function<int(int, int)> comfun;// 普通函数
int add(int a, int b) { return a + b; }// lambda表达式
auto mod = [](int a, int b){ return a % b; };// 函数对象类
struct divide{int operator()(int denominator, int divisor){return denominator/divisor;}
};int main(){comfun a = add;comfun b = mod;comfun c = divide();std::cout << a(5, 3) << std::endl;std::cout << b(5, 3) << std::endl;std::cout << c(5, 3) << std::endl;
}

std::function可以取代函数指针的作用，因为它可以延迟函数的执行，特别适合作为回调函数使用。它比普通函数指针更加的灵活和便利。
故而，std::function的作用可以归结于：
1.std::function对C++中各种可调用实体(普通函数、Lambda表达式、函数指针、以及其它函数对象等)的封装，形成一个新的可调用的std::function对象，简化调用；
2.std::function对象是对C++中现有的可调用实体的一种类型安全的包裹(如：函数指针这类可调用实体，是类型不安全的)。

6.bind

std::bind可以看作一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来适应原对象的参数列表。

std::bind将可调用对象与其参数一起进行绑定，绑定后的结果可以使用std::function保存。std::bind主要有以下两个作用：

将可调用对象和其参数绑定成一个仿函数；
只绑定部分参数，减少可调用对象传入的参数。
调用bind的一般形式：

auto newCallable = bind(callable, arg_list);

该形式表达的意思是：当调用newCallable时，会调用callable，并传给它arg_list中的参数。

需要注意的是：arg_list中的参数可能包含形如_n的名字。其中n是一个整数，这些参数是占位符，表示newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

#include <iostream>
#include <functional>class A {
public:void fun_3(int k,int m) {std::cout << "print: k = "<< k << ", m = " << m << std::endl;}
};void fun_1(int x,int y,int z) {std::cout << "print: x = " << x << ", y = " << y << ", z = " << z << std::endl;
}void fun_2(int &a,int &b) {++a;++b;std::cout << "print: a = " << a << ", b = " << b << std::endl;
}int main(int argc, char * argv[]) {//f1的类型为 function<void(int, int, int)>auto f1 = std::bind(fun_1, 1, 2, 3); 					//表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3f1(); 													//print: x=1,y=2,z=3auto f2 = std::bind(fun_1, std::placeholders::_1, std::placeholders::_2, 3);//表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f2 的第一，二个参数指定f2(1, 2);												//print: x=1,y=2,z=3auto f3 = std::bind(fun_1, std::placeholders::_2, std::placeholders::_1, 3);//表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f3 的第二，一个参数指定//注意： f2  和  f3 的区别。f3(1, 2);												//print: x=2,y=1,z=3int m = 2;int n = 3;auto f4 = std::bind(fun_2, std::placeholders::_1, n); //表示绑定fun_2的第一个参数为n, fun_2的第二个参数由调用f4的第一个参数（_1）指定。f4(m); 													//print: a=3,b=4std::cout << "m = " << m << std::endl;					//m=3  说明：bind对于不事先绑定的参数，通过std::placeholders传递的参数是通过引用传递的,如mstd::cout << "n = " << n << std::endl;					//n=3  说明：bind对于预先绑定的函数参数是通过值传递的，如nA a;//f5的类型为 function<void(int, int)>auto f5 = std::bind(&A::fun_3, &a, std::placeholders::_1, std::placeholders::_2); //使用auto关键字f5(10, 20);												//调用a.fun_3(10,20),print: k=10,m=20std::function<void(int,int)> fc = std::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2);fc(10, 20);   											//调用a.fun_3(10,20) print: k=10,m=20 return 0; 
}

编译并运行：

print: x = 1, y = 2, z = 3
print: x = 1, y = 2, z = 3
print: x = 2, y = 1, z = 3
print: a = 3, b = 4
m = 3
n = 3
print: k = 10, m = 20
print: k = 10, m = 20

由此例子可以看出：

预绑定的参数是以值传递的形式，不预绑定的参数要用std::placeholders(占位符)的形式占位，从_1开始，依次递增，是以引用传递的形式；
std::placeholders表示新的可调用对象的第几个参数，而且与原函数的该占位符所在位置的进行匹配；
bind绑定类成员函数时，第一个参数表示对象的成员函数的指针，第二个参数表示对象的地址，这是因为对象的成员函数需要有this指针。并且编译器不会将对象的成员函数隐式转换成函数指针，需要通过&手动转换；
std::bind的返回值是可调用实体，可以直接赋给std::function。

参考一

参考二