C++之function和bind用法

最新推荐文章于 2024-05-05 14:07:58 发布

毛毛不怕困难

最新推荐文章于 2024-05-05 14:07:58 发布

阅读量1k

点赞数 1

分类专栏： C/C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/axyw_/article/details/133300000

版权

C/C++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

在设计回调函数的时候，无可避免地会接触到可回调对象。在C++11中，提供了std::function和std::bind两个方法来对可回调对象进行统一和封装。

C++语言中有几种可调用对象：函数、函数指针、lambda表达式、bind创建的对象以及重载了函数调用运算符的类。

和其他对象一样，可调用对象也有类型。例如，每个lambda有它自己唯一的（未命名）类类型；函数及函数指针的类型则由其返回值类型和实参类型决定。

1. function的用法

保存普通函数

//保存普通函数
void func1(int a)
{
cout << a << endl;
}
//1. 保存普通函数
std::function<void(int a)> func;
func = func1;
func(2); //2

保存lambda表达式

std::function<void()> func_1 = [](){cout << "hello world" << endl;};
func_1(); //hello world

保存成员函数

//保存成员函数
class A{
public:
	A(string name) : name_(name){}
	void func3(int i) const {cout <<name_ << ", " << i << endl;}
private:
	string name_;
};
//3 保存成员函数
std::function<void(const A&,int)> func3_ = &A::func3;
A a("darren");
func3_(a, 1);

2. bind用法

对应bind绑定的函数重载的问题具体见源码

可将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
调用bind的一般形式：auto newCallable = bind(callable, arg_list);其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。即，当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。
arg_list中的参数可能包含形如n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：1为newCallable的第一个参数，_2为第二个参数，以此类推。

以下是一些使用std::bind的详细示例：

示例1：将成员函数作为回调函数传递

#include <iostream>
#include <functional>

class MyClass {
public:
    void print_hello() const {
        std::cout << "Hello from MyClass!" << std::endl;
    }
};

void foo(const std::function<void()>& callback) {
    callback();
}

int main() {
    MyClass obj;
    std::function<void()> bound_callback = std::bind(&MyClass::print_hello, &obj);
    foo(bound_callback);
    return 0;
}

示例2：使用std::bind将成员函数与对象实例绑定

#include <iostream>
#include <functional>

class MyClass {
public:
    void print_sum(int a, int b) const {
        std::cout << "Sum: " << (a + b) << std::endl;
    }
};

int main() {
    MyClass obj;
    std::function<void(int, int)> bound_callback = std::bind(&MyClass::print_sum, &obj, std::placeholders::_1, std::placeholders::_2);
    bound_callback(3, 4); // 输出 "Sum: 7"
    return 0;
}

示例3：使用std::bind将成员函数与对象实例和参数绑定

#include <iostream>
#include <functional>

class MyClass {
public:
    void print_message(const std::string& msg, int times) const {
        for (int i = 0; i < times; ++i) {
            std::cout << msg << std::endl;
        }
    }
};

int main() {
    MyClass obj;
    std::function<void(const std::string&, int)> bound_callback = std::bind(&MyClass::print_message, &obj, std::placeholders::_1, std::placeholders::_2);
    bound_callback("Hello, World!", 5); // 输出 "Hello, World!" 5次
    return 0;
}

3.可变参数模板

C++11的新特性–可变模版参数（variadic templates）是C++11新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数

3.1 可变模版参数的展开

可变参数模板语法

template <class... T>
void f(T... args);

上面的可变模版参数的定义当中，省略号的作用有两个：

声明一个参数包T… args，这个参数包中可以包含0到任意个模板参数；
在模板定义的右边，可以将参数包展开成一个一个独立的参数。

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。
可变模版参数和普通的模版参数语义是一致的，所以可以应用于函数和类，即可变模版参数函数和可变模版参数类，然而，模版函数不支持偏特化，所以可变模版参数函数和可变模版参数类展开可变模版参数的方法还不尽相同，下面我们来分别看看他们展开可变模版参数的方法。

3.1.1 可变模版参数函数

// 一个简单的可变模版参数函数
#include <iostream>
using namespace std;


template <class... T>
void f(T... args)
{
    cout << sizeof...(args) << endl; // 打印变参的个数
}


int main()
{
    f();           // 0
    f(1, 2);       // 2
    f(1, 2.5, "",12222); // 3
    return 0;
}

上面的例子中，f()没有传入参数，所以参数包为空，输出的size为0，后面两次调用分别传入两个和三个参数，故输出的size分别为2和3。由于可变模版参数的类型和个数是不固定的，所以我们可以传任意类型和个数的参数给函数f。这个例子只是简单的将可变模版参数的个数打印出来，如果我们需要将参数包中的每个参数打印出来的话就需要通过一些方法了。

展开可变模版参数函数的方法一般有两种：

通过递归函数来展开参数包，
是通过逗号表达式来展开参数包。

下面来看看如何用这两种方法来展开参数包。

递归函数方式展开参数包

通过递归函数展开参数包，需要提供一个参数包展开的函数和一个递归终止函数，递归终止函数正是用来终止递归的

// 3-1-variable-parameter2 递归函数方式展开参数包
#include <iostream>
using namespace std;

// 递归终止函数
void print()
{
    cout << "empty" << endl;
}

// 展开函数
template <class T, class... Args>
void print(T head, Args... rest)
{
    cout << "parameter " << head << endl;
    print(rest...);
}

int main(void)
{
    print(1, 2, 3, 4);
    return 0;
}

上例会输出每一个参数，直到为空时输出empty。展开参数包的函数有两个，一个是递归函数，另外一个是递归终止函数，参数包Args…在展开的过程中递归调用自己，每调用一次参数包中的参数就会少一个，直到所有的参数都展开为止，当没有参数时，则调用非模板函数print终止递归过程。
上面的递归终止函数还可以写成这样：

template <class T>
void print(T t)
{
cout << t << endl;
}

逗号表达式展开参数包

递归函数展开参数包是一种标准做法，也比较好理解，但也有一个缺点,就是必须要一个重载的递归终止函数，即必须要有一个同名的终止函数来终止递归，这样可能会感觉稍有不便。有没有一种更简单的方式呢？其实还有一种方法可以不通过递归方式来展开参数包，这种方式需要借助逗号表达式和初始化列表。比如前面print的例子可以改成这样：

// 3-1-variable-parameter3 逗号表达式展开参数包
#include <iostream>
using namespace std;

template <class T>
void printarg(T t)
{
    cout << t << endl;
}

template <class... Args>
void expand(Args... args)
{
    int arr[] = {(printarg(args), 0)...};
}

int main()
{
    expand(1, 2, 3, 4);
    return 0;
}

这个例子将分别打印出1,2,3,4四个数字。这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。
expand函数中的逗号表达式：(printarg(args), 0)，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组,{(printarg(args), 0)…}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc… )，最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。我们可以把上面的例子再进一步改进一下，将函数作为参数，就可以支持lambda表达式了，从而可以少写一个递归终止函数了，具体代码如下：

//3-1-variable-parameter4
#include <iostream>
using namespace std;
template<class F, class... Args>void expand(const F& f, Args&&...args)
{
//这里用到了完美转发
initializer_list<int>{(f(std::forward< Args>(args)),0)...};
}
int main()
{
expand([](int i){cout<<i<<endl;}, 1,2,3);
return 0;
}