std::function和std::bind的使用

最新推荐文章于 2025-03-27 00:13:54 发布
原创 最新推荐文章于 2025-03-27 00:13:54 发布 · 4.2k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#蓝桥杯 #c++ #职场和发展

本文详细介绍了C++中的std::function，包括如何包装普通函数、模板函数、函数对象、类模板成员函数以及普通类的成员函数。还展示了如何使用lambda表达式和std::function的拷贝、移动特性。通过实例展示了std::function的灵活性和通用性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

一、std::function

1.包装普通的函数

2.包装模板函数

3.包装函数对象

4.类模板

5.普通类

6.lambda表达式

7.std::function的拷贝、移动

一、std::function

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

1.包装普通的函数

std::function<int(int)> callback;

//1.普通的函数
int func(int a){
    std::cout<< "func_ a :" << a << endl;
    return a;
}


int main()
{
    //1.包装普通的函数
    callback = func;
    callback(10); 

    return 0;
}

2.包装模板函数

template<class T>
T func_template(T a)
{
  std::cout<< "func_template a :" << a << endl;
  return a;
}

int main()
{
    //2.包装模板函数 
    callback = func_template<double>;
    callback(20.0); //结果为2，这里callback是int类型的，所以都会转成int
    return 0;
}

3.包装函数对象

//3.函数对象
class FucntionClass
{
public:
    int operator()(int  a){
        std::cout<< "FucntionClass a :" << a << endl;
        return a;
    }
};

int main()
{
    //3.包装函数对象
    callback = FucntionClass();
    callback(30);
    return 0;
}

4.类模板

template<class T1>
class FunctionClass_template
{
public:
    T1 operator()(T1 a){
        std::cout<< "template() a :" << a << endl;
        return a;
    }

    static T1 static_func(T1 a){
        std::cout<< "template func a :" << a << endl;
        return a;
    }

    T1 foo(T1 a){
         std::cout<< "template foo a :" << a << endl;
         return a;
    }
};


int main()
{
    //4.类模板
    //4.1模板对象函数
    callback = FunctionClass_template<int>();
    callback(41);
    //4.2类模板static函数
    callback = FunctionClass_template<int>::static_func; //static 函数
    callback(42);
    //4.3类模板普通函数  
    FunctionClass_template<int> f_template;
    callback = std::bind(&FunctionClass_template<int>::foo,f_template,
    std::placeholders::_1);
    callback(43);

    return 0;
}

5.普通类

#include <iostream>
#include <functional>
using namespace std;
class MyClass
{
public:
    int operator()(int a){
        std::cout<< "MyClass() a :" << a << endl;
    }
    static int static_func(int a){
        std::cout<< "MyCLass  static_func a :" << a << endl;
        return a;
    }
    int foo(int a){
        std::cout<< "MyCLass  foo a :" << a << endl;
        return a;
    }
};

int main()
{
    //5.普通类
    //5.1对象函数
    callback = MyClass();
    callback(51);
    //5.2类内静态函数
    callback = MyClass::static_func;
    callback(52);
    //5.3类内普通函数
    MyClass f_myclass;
    callback = std::bind(&MyClass::foo,f_myclass,std::placeholders::_1);
    callback(53);

    return 0;
}

6.lambda表达式

  auto f_lambda = [](int a){
        std::cout << "lambda   a:" << a << std::endl;
        return a;
    };
  callback = f_lambda;
  callback(61);

7.std::function的拷贝、移动


    std::function<int(int)>callback_2 = callback;
    callback_2(71);

    std::function<int(int)>callback_3(callback);
    callback_3(72);

    std::function<int(int)>&& callback_4 = std::move(callback);
    callback_4(73);

  cpp文件如下：

#include <iostream>
#include <functional>

using namespace std;

std::function<int(int)> callback;

//1.普通的函数
int func(int a){
    std::cout<< "func_ a :" << a << endl;
    return a;
}

//2.类模板函数

template<class T>
T func_template(T a)
{
  std::cout<< "func_template a :" << a << endl;
  return a;
}

//3.函数对象
class FucntionClass
{
public:
    int operator()(int  a){
        std::cout<< "FucntionClass a :" << a << endl;
        return a;
    }
};

//4.模板对象函数
template<class T1>
class FunctionClass_template
{
public:
    T1 operator()(T1 a){
        std::cout<< "template() a :" << a << endl;
        return a;
    }

    static T1 static_func(T1 a){
        std::cout<< "template func a :" << a << endl;
        return a;
    }

    T1 foo(T1 a){
         std::cout<< "template foo a :" << a << endl;
         return a;
    }
};

class MyClass
{
public:
    int operator()(int a){
        std::cout<< "MyClass() a :" << a << endl;
    }
    static int static_func(int a){
        std::cout<< "MyCLass  static_func a :" << a << endl;
        return a;
    }
    int foo(int a){
        std::cout<< "MyCLass  foo a :" << a << endl;
        return a;
    }
};

template <typename T>
class foo4{
public:
    T foo(T a){
        return a * 6;
    }
};

int main()
{
    //一般出现问题都是callback的参数or返回值类型和自定义的不匹配所致
  
    //1.包装普通的函数
    callback = func;
    callback(10); 

    //2.包装模板函数 
    callback = func_template<double>;
    callback(20.0); //结果为2，这里callback是int类型的，所以都会转成int

    //3.包装函数对象
    callback = FucntionClass();
    callback(30);

   
    //4.类模板
    //4.1模板对象函数
    callback = FunctionClass_template<int>();
    callback(41);
    //4.2类模板static函数
    callback = FunctionClass_template<int>::static_func; //static 函数
    callback(42);
    //4.3类模板普通函数  
    FunctionClass_template<int> f_template;
    callback = std::bind(&FunctionClass_template<int>::foo,f_template, std::placeholders::_1);
    callback(43);

    //5.普通类
    //5.1对象函数
    callback = MyClass();
    callback(51);
    //5.2类内静态函数
    callback = MyClass::static_func;
    callback(52);
    //5.3类内普通函数
    MyClass f_myclass;
    callback = std::bind(&MyClass::foo,f_myclass,std::placeholders::_1);
    callback(53);

    //6.lambda表达式

    auto f_lambda = [](int a){
        std::cout << "lambda   a:" << a << std::endl;
        return a;
    };

    callback = f_lambda;
    callback(61);

    //7.std::function的拷贝、移动

    std::cout << " ------------ " << std::endl;
    std::function<int(int)>callback_2 = callback;
    callback_2(71);

    std::function<int(int)>callback_3(callback);
    callback_3(72);

    std::function<int(int)>&& callback_4 = std::move(callback);
    callback_4(73);
    
    return 0;
}

2.std::bind

bind相当于一个适配器模板类

上图中的callfunc1是我们已经实现的函数，newCall是通过std::bind重新包装的函数。

bind的函数原型：
auto newfunc = bind(func, arg_list);
该形式表达的意思是：当调用newfunc时，会调用func，并传给它arg_list中的参数。

实战中
auto newCall = std::bind(callfunc1,std::placeholders::_1,20);

newCall可以只接收一个参数，调用newCall后会调用callfunc1,比如现在执行了
newCall(99);
这时回调给callfunc1的就是 callfunc1(99,20);

2.类内函数，要将this传参哦

class A {
public:
    void fun(int k,int m) {
        cout << " k="<< k << ", m = " << m <<endl;
    }
};

A a;
auto newClassCall = std::bind(&A::fun,&a,std::placeholders::_1,11);
newClassCall(15);

青青子衿0
关注
C++11 新特性 ④ | 模板类 std::function 和标准库函数 std::bind
dvlinker的技术专栏
09-09 1万+
详细讲解模板类std::function和标准库函数std::bind。
C++之std:: function和std::bind
专注
05-16 959
std::function 是 C++ 标准库中的一个类模板，包含在头文件中，它用于封装可以调用的任意可调用对象，包括函数指针、函数对象、Lambda 表达式等。std::function 提供了一种通用的方式来存储、复制和调用可调用对象，使得可以将它们作为参数传递给其他函数、存储在容器中，或者作为返回值返回。它是一种多态函数包装器，可以在运行时决定具体要调用的函数或函数对象。代码：保存普通函数和类成员函数。
C++11 中std::function和std::bind的用法
weixin_34352005的博客
04-08 161
2019独角兽企业重金招聘Python工程师标准>>> ...
9.std::function使用
最新发布
weixin_38738238的博客
03-27 232
中括号中的参数会绑定到std::function对象内部，可以使用传引用和传值的方式传入。实参->形参：拷贝构造，形参->function对象内部：移动构造。std::function内部传入的值不会调用拷贝构造或是移动构造。std::function内部传入的值也会拷贝构造一次。不会调用对象的移动构造和拷贝构造函数。
std::function和std::bind用法
热门推荐
wang371372的专栏
09-04 1万+
std::bind（）        std::bind 主要用于绑定生成目标函数，一般用于生成的回调函数，cocos的回退函数都是通过std::bind和std::function实现的。两个点要明白： 1.绑定全局或者静态函数比绑定成员函数少了个成员变量，且不需要引用如下 //绑定全局函数 auto pfunc = std::bind(func1, 3); //绑定静态函数 pfunc...
std::function和std::bind详解
吾生也有涯，而知也无涯
02-22 9462
std::functionstd::function包含于头文件 #include&lt;functional&gt;中，可将各种可调用实体进行封装统一，包括普通函数lambda表达式函数指针仿函数(functor 重载括号运算符实现)类成员函数静态成员函数下面实例通过上述几种方式实现一个简单的比较两个数的大小的功能：#include &lt;iostream&gt; #include &lt;f...
C++ 学习系列 -- std::function 与 std::bind
qq_33775774的博客
01-20 2515
std::function 是 c++ 11 的新特性 ，包含在头文件<functional>中，为了更方便的调用函数而引入。std::function 是一个函数包装器（function wrapper），可以包装任何可调用实体，包括如下几种：普通函数、函数指针、成员函数、静态函数、lambda 表达式 与 仿函数对象。std::function 对象实例可以拷贝与移动，可以使用指定的调用特征来调用目标元素。
C++ 11 std::function和std::bind使用详解
08-25
下面将详细介绍这两个功能的使用和区别。 std::function 是一个可调用对象的包装器，用于存储和调用函数指针。std::function 可以绑定到全局函数、类静态成员函数或 lambda 表达式。std::function 的定义是 std::...
C++11中lambda、std::function和std:bind详解
08-31
这篇文主要关注三个核心概念：lambda表达式、std::function和std::bind。 **Lambda表达式**是C++11引入的一种内联匿名函数，它允许我们在需要的地方直接定义函数对象，而无需单独声明一个函数。Lambda表达式的语法...
通过c++11的std::bind及std::function实现类方法回调，模拟Qt实现信号槽
10-06
c++11引入了std::bind及std::function，实现了函数的存储和绑定，即先将可调用的对象保存起来，在需要的时候再调用。定义了SignalObject信号类和SlotObject槽类，其中信号类中的 std::function(int)> _call就是要...
std::function 和 std::bind
weixin_41752434的博客
03-13 3064
std::function 仿函数对象 std::function 用来声明函数对象的，换句话说，就和函数指针、Lambda表达式、函数名是一个东西 。 #include <iostream> #include <functional> // 传统C函数 int c_function(int a, int b) { return a + b; } int main(int argc, char** argv) { // 万能可调用对象类型 std.
C++11: std::function和std::bind的用法
youtiao_hulatang的博客
03-30 588
一、关于std::function 的用法： 其实就可以理解成函数指针 格式：std::function<函数指针类型> = 函数（lambda表达式、成员函数） 1. 保存自由函数 void printA(int a) { cout<<a<<endl; } std::function<void(int a)> func; func...
std::bind与std::function
小吴同学的小屋
10-15 367
std::bind与std::function std::bind 调用std::bind的一般形式为 auto newCallable = bind(callable, arg_list); newCallable本身是一个可调用对象，arg_list是一个用逗号分隔的参数列表。当我们调用newCallable的时候会调用callable并且传给它arg_list里面的参数 std::bind是c++11的新特性，它接受一个可调用对象生成一个新的可调用对象来适应原对象的参数列表。举一个例子 bool
std::function和std::bind
qq_42896106的博客
05-23 271
std::function和std::bind std::function 可调用对象 是一个函数指针 是一个具有operator()成员函数的类和对象 可被转换成函数指针的类对象； 一个类成员函数指针； C++中可调用对象的虽然都有一个比较统一的操作形式，但是定义方法五花八门，这样就导致使用统一的方式保存可调用对象或者传递可调用对象时，会十分繁琐。C++11中提供了std::function和std::bind统一了可调用对象的各种操作。 // 普通函数 int add(int a, int b
std::function与std::bind
zhghost的专栏
01-06 1421
一、背景介绍：函数指针始终不太灵活，它只能指向全局或静态函数，对于类成员函数、lambda表达式或其他可调用对象就无能为力了，因此，C++11推出了std::function与std::b...
C++ std::function和std::bind的六种用法总结
m0_64098026的博客
05-29 639
1，使用function接收普通函数2，使用function接收lambda函数3，使用function函数来接收函数对象4，使用bind函数绑定类中的一般函数5，使用bind函数绑定类中的多态函数6，使用function来实现回调。
C++11 中的function和bind、lambda用法
weixin_30357231的博客
03-20 221
std::function 1. std::bind绑定一个成员函数 1 #include <iostream> 2 #include <functional> 3 4 struct Foo 5 { 6 void print_sum(int n1, int n2) 7 { 8 std::c...
std::bind std::function 使用示例
11-16
下面是一个使用std::function和std::bind的示例： ```c++ #include <iostream> #include <functional> void printNum(int num) { std::cout << "Number: " << num << std::endl; } int main() { // 使用std::function定义一个函数对象 std::function<void(int)> funcObj; // 使用std::bind绑定函数和参数，返回一个函数对象 funcObj = std::bind(&printNum, std::placeholders::_1); // 调用函数对象 funcObj(123); return 0; } ``` 上述代码中，我们首先定义了一个名为`printNum`的函数，该函数接受一个整数参数并将其打印到控制台上。然后，我们使用`std::function`定义了一个函数对象`funcObj`，该函数对象接受一个整数参数并不返回任何值。接下来，我们使用`std::bind`将`printNum`函数和占位符`std::placeholders::_1`绑定在一起，返回一个函数对象，并将该函数对象赋值给`funcObj`。最后，我们调用`funcObj`并传递一个整数参数123，该整数参数将被传递给`printNum`函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值