c++11:可调用对象

一定会升职加薪

已于 2024-02-27 11:21:29 修改

阅读量1.3k

点赞数 43

分类专栏：燃犀的C++笔记文章标签： c++ 开发语言

于 2024-02-23 17:53:52 首次发布

本文链接：https://blog.csdn.net/qq_43611366/article/details/136260914

版权

燃犀的C++笔记专栏收录该内容

48 篇文章 1 订阅

订阅专栏

本文详细介绍了C++11中的可调用对象，包括普通函数、函数指针、仿函数（Lambda表达式）、function对象以及std::function和std::bind的用法，展示了它们在函数调用和参数绑定中的应用。

摘要由CSDN通过智能技术生成

引言

可调用对象是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 (*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);//50
	return 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 3
    f1(); 													//print: x=1,y=2,z=3

    auto 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=3
 
    auto 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=3

    int 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=4
    std::cout << "m = " << m << std::endl;					//m=3  说明：bind对于不事先绑定的参数，通过std::placeholders传递的参数是通过引用传递的,如m
    std::cout << "n = " << n << std::endl;					//n=3  说明：bind对于预先绑定的函数参数是通过值传递的，如n
    
    A 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=20

    std::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。

参考一

参考二