C++11 std::bind std::function 高级用法

最新推荐文章于 2023-07-30 20:03:10 发布
最新推荐文章于 2023-07-30 20:03:10 发布
阅读量261 收藏
点赞数
分类专栏： c++

从最基础的了解，std::bind和std::function

[cpp] view plain copy
print ?
  1. /*  
  2.  * File:   main.cpp 
  3.  * Author: Vicky.H 
  4.  * Email:  eclipser@163.com 
  5.  */  
  6. #include <iostream>  
  7. #include <functional>  
  8. #include <typeinfo>  
  9. #include <string.h>  
  10.   
  11. int add1(int i, int j, int k) {  
  12.     return i + j + k;  
  13. }  
  14.   
  15.   
  16. class Utils {  
  17. public:  
  18.     Utils(const char* name) {  
  19.         strcpy(_name, name);  
  20.     }  
  21.       
  22.     void sayHello(const char* name) const {  
  23.         std::cout << _name << " say: hello " << name << std::endl;  
  24.     }  
  25.       
  26.     static int getId() {  
  27.         return 10001;  
  28.     }   
  29.       
  30.     int operator()(int i, int j, int k) const {  
  31.         return i + j + k;  
  32.     }  
  33.       
  34. private:  
  35.     char _name[32];  
  36. };  
  37.   
  38.   
  39. /* 
  40.  *  
  41.  */  
  42. int main(void) {  
  43.       
  44.     // 绑定全局函数  
  45.     auto add2 = std::bind(add1, std::placeholders::_1, std::placeholders::_2, 10);  
  46.     // 函数add2 = 绑定add1函数，参数1不变，参数2不变，参数3固定为10.  
  47.     std::cout << typeid(add2).name() << std::endl;  
  48.     std::cout << "add2(1,2) = " << add2(1, 2) << std::endl;  
  49.       
  50.     std::cout << "\n---------------------------" << std::endl;  
  51.       
  52.     // 绑定成员函数  
  53.     Utils utils("Vicky");  
  54.     auto sayHello = std::bind(&Utils::sayHello, utils/*调用者*/, std::placeholders::_1/*参数1*/);  
  55.     sayHello("Jack");  
  56.       
  57.     auto sayHelloToLucy = std::bind(&Utils::sayHello, utils/*调用者*/, "Lucy"/*固定参数1*/);  
  58.     sayHelloToLucy();  
  59.       
  60.     // 绑定静态成员函数  
  61.     auto getId = std::bind(&Utils::getId);  
  62.     std::cout << getId() << std::endl;  
  63.       
  64.     std::cout << "\n---------------------------" << std::endl;  
  65.       
  66.     // 绑定operator函数  
  67.     auto add100 = std::bind(&Utils::operator (), utils, std::placeholders::_1, std::placeholders::_2, 100);  
  68.     std::cout << "add100(1, 2) = " << add100(1, 2) << std::endl;  
  69.       
  70.     // 注意：无法使用std::bind()绑定一个重载函数  
  71.       
  72.     return 0;  
  73. }  
/* 
 * File:   main.cpp
 * Author: Vicky.H
 * Email:  eclipser@163.com
 */
#include <iostream>
#include <functional>
#include <typeinfo>
#include <string.h>

int add1(int i, int j, int k) {
    return i + j + k;
}


class Utils {
public:
    Utils(const char* name) {
        strcpy(_name, name);
    }
    
    void sayHello(const char* name) const {
        std::cout << _name << " say: hello " << name << std::endl;
    }
    
    static int getId() {
        return 10001;
    } 
    
    int operator()(int i, int j, int k) const {
        return i + j + k;
    }
    
private:
    char _name[32];
};


/*
 * 
 */
int main(void) {
    
    // 绑定全局函数
    auto add2 = std::bind(add1, std::placeholders::_1, std::placeholders::_2, 10);
    // 函数add2 = 绑定add1函数，参数1不变，参数2不变，参数3固定为10.
    std::cout << typeid(add2).name() << std::endl;
    std::cout << "add2(1,2) = " << add2(1, 2) << std::endl;
    
    std::cout << "\n---------------------------" << std::endl;
    
    // 绑定成员函数
    Utils utils("Vicky");
    auto sayHello = std::bind(&Utils::sayHello, utils/*调用者*/, std::placeholders::_1/*参数1*/);
    sayHello("Jack");
    
    auto sayHelloToLucy = std::bind(&Utils::sayHello, utils/*调用者*/, "Lucy"/*固定参数1*/);
    sayHelloToLucy();
    
    // 绑定静态成员函数
    auto getId = std::bind(&Utils::getId);
    std::cout << getId() << std::endl;
    
    std::cout << "\n---------------------------" << std::endl;
    
    // 绑定operator函数
    auto add100 = std::bind(&Utils::operator (), utils, std::placeholders::_1, std::placeholders::_2, 100);
    std::cout << "add100(1, 2) = " << add100(1, 2) << std::endl;
    
    // 注意：无法使用std::bind()绑定一个重载函数
    
    return 0;
}


[cpp] view plain copy
print ?
  1. /*  
  2.  * File:   main2.cpp 
  3.  * Author: Vicky.H 
  4.  * Email:  eclipser@163.com 
  5.  */  
  6. #include <iostream>  
  7. #include <typeinfo>  
  8.   
  9.   
  10. void sayHello() {  
  11.     std::cout << "Hello world !" << std::endl;  
  12. }  
  13.   
  14. int sum(int i, int j, int k) {  
  15.     return i + j + k;  
  16. }  
  17.   
  18. template <typename T>  
  19. class Func {  
  20. public:  
  21.   
  22.     Func(T fun) {  
  23.         if (!fun) {  
  24.             throw "fun nullptr";  
  25.         }  
  26.         _fun = fun;  
  27.     }  
  28.   
  29.     template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5>  
  30.     R Call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {  
  31.         return _fun(a1, a2, a3, a4, a5);  
  32.     }  
  33.   
  34.     template<typename R, typename A1, typename A2, typename A3, typename A4>  
  35.     R Call(A1 a1, A2 a2, A3 a3, A4 a4) {  
  36.         return _fun(a1, a2, a3, a4);  
  37.     }  
  38.   
  39.     template<typename R, typename A1, typename A2, typename A3>  
  40.     R Call(A1 a1, A2 a2, A3 a3) {  
  41.         return _fun(a1, a2, a3);  
  42.     }  
  43.   
  44.     template<typename R, typename A1, typename A2>  
  45.     R Call(A1 a1, A2 a2) {  
  46.         return _fun(a1, a2);  
  47.     }  
  48.   
  49.     template<typename R, typename A1>  
  50.     R Call(A1 a1) {  
  51.         return _fun(a1);  
  52.     }  
  53.   
  54.     template<typename R>  
  55.     R Call() {  
  56.         return _fun();  
  57.     }  
  58.   
  59.     void Call() {  
  60.         _fun();  
  61.     }  
  62.   
  63. private:  
  64.     T _fun;  
  65. };  
  66.   
  67. #include <functional>  
  68.   
  69. template<typename R = void, typename... Args>  
  70. class Fn {  
  71. public:  
  72.     Fn(std::function<R(Args...)> fun) : _fun(fun) {  
  73.     }  
  74.       
  75.     R operator()(Args... args) {  
  76.         return _fun(args...);  
  77.     }  
  78. private:  
  79.     std::function<R(Args...) > _fun;  
  80. };  
  81.   
  82. /* 
  83.  * 将函数注册到对象中，通过对象直接调用 
  84.  */  
  85. int main(void) {  
  86.   
  87.   
  88.     Func<void(*)() > sayHelloFunc(sayHello);  
  89.     sayHelloFunc.Call();  
  90.   
  91.   
  92.     Func<int (*)(int, int, int) > sumFunc(sum);  
  93.     std::cout << "sumFunc.Call<int>(1, 2, 3) : " << sumFunc.Call<int>(1, 2, 3) << std::endl;  
  94.   
  95.   
  96.     std::cout << "\n---------------------------" << std::endl;  
  97.   
  98.     Fn<> sayHelloFn(sayHello);  
  99.     sayHelloFn();  
  100.       
  101.     Fn<int, int, int, int> sumFn(sum);  
  102.     std::cout << "sumFn(1, 2, 3) : " << sumFn(1, 2, 3) << std::endl;  
  103.   
  104.     std::cout << "\n---------------------------" << std::endl;  
  105.   
  106.     return 0;  
  107. }  
/* 
 * File:   main2.cpp
 * Author: Vicky.H
 * Email:  eclipser@163.com
 */
#include <iostream>
#include <typeinfo>


void sayHello() {
    std::cout << "Hello world !" << std::endl;
}

int sum(int i, int j, int k) {
    return i + j + k;
}

template <typename T>
class Func {
public:

    Func(T fun) {
        if (!fun) {
            throw "fun nullptr";
        }
        _fun = fun;
    }

    template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5>
    R Call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
        return _fun(a1, a2, a3, a4, a5);
    }

    template<typename R, typename A1, typename A2, typename A3, typename A4>
    R Call(A1 a1, A2 a2, A3 a3, A4 a4) {
        return _fun(a1, a2, a3, a4);
    }

    template<typename R, typename A1, typename A2, typename A3>
    R Call(A1 a1, A2 a2, A3 a3) {
        return _fun(a1, a2, a3);
    }

    template<typename R, typename A1, typename A2>
    R Call(A1 a1, A2 a2) {
        return _fun(a1, a2);
    }

    template<typename R, typename A1>
    R Call(A1 a1) {
        return _fun(a1);
    }

    template<typename R>
    R Call() {
        return _fun();
    }

    void Call() {
        _fun();
    }

private:
    T _fun;
};

#include <functional>

template<typename R = void, typename... Args>
class Fn {
public:
    Fn(std::function<R(Args...)> fun) : _fun(fun) {
    }
    
    R operator()(Args... args) {
        return _fun(args...);
    }
private:
    std::function<R(Args...) > _fun;
};

/*
 * 将函数注册到对象中，通过对象直接调用
 */
int main(void) {


    Func<void(*)() > sayHelloFunc(sayHello);
    sayHelloFunc.Call();


    Func<int (*)(int, int, int) > sumFunc(sum);
    std::cout << "sumFunc.Call<int>(1, 2, 3) : " << sumFunc.Call<int>(1, 2, 3) << std::endl;


    std::cout << "\n---------------------------" << std::endl;

    Fn<> sayHelloFn(sayHello);
    sayHelloFn();
    
    Fn<int, int, int, int> sumFn(sum);
    std::cout << "sumFn(1, 2, 3) : " << sumFn(1, 2, 3) << std::endl;

    std::cout << "\n---------------------------" << std::endl;

    return 0;
}

Hello world !
sumFunc.Call<int>(1, 2, 3) : 6


---------------------------
Hello world !
sumFn(1, 2, 3) : 6


---------------------------

上面的例子非常有趣，使用了2种方案，将一个函数，注册到一个对象/仿函数中，并且通过一个对象/仿函数来直接调用调用。
例子显而易见的，第2种方案更佳简洁，并且对传递参数有明确的判断，当参数类型或数量不正确的时候，编译器将导致失败。
这种方案，可以将类的成员变量直接作为函数的参数使用，或者，如我：
http://blog.csdn.net/eclipser1987/article/details/23926395
这篇文章中，无法直接调用脚本函数类，有了好的解决办法。这个我将随后补充。




[cpp] view plain copy
print ?
  1. #include <list>  
  2. #include <functional>  
  3.   
  4. template<typename... Args>  
  5. class Fns  
  6. {  
  7. private:  
  8.   
  9.     std::list<std::function<void(Args...)> > _calls;  
  10.   
  11. public:  
  12.   
  13.     virtual ~Fns()  
  14.     {  
  15.         _calls.clear();  
  16.     }  
  17.   
  18.     void connect(std::function<void(Args...)> fct)  
  19.     {  
  20.         _calls.push_back(fct);  
  21.     }  
  22.   
  23.     template<typename Object>  
  24.     void connect(Object* object, void (Object::*method)(Args...))  
  25.     {  
  26.         _calls.push_back([object,method](Args... args){(*object.*method)(args...);});  
  27.     }  
  28.   
  29.     template<typename Object>  
  30.     void connect(Object* object, void (Object::*method)(Args...) const)  
  31.     {  
  32.         _calls.push_back([object,method](Args... args){(*object.*method)(args...);});  
  33.     }  
  34.   
  35.     template<typename Object>  
  36.     void connect(const Object* object, void (Object::*method)(Args...) const)  
  37.     {  
  38.         _calls.push_back([object,method](Args... args){(*object.*method)(args...);});  
  39.     }  
  40.   
  41.     void emit(Args... args)  
  42.     {  
  43.         for(auto call : _calls)  
  44.             call(args...);  
  45.     }  
  46. };  
#include <list>
#include <functional>

template<typename... Args>
class Fns
{
private:

	std::list<std::function<void(Args...)> > _calls;

public:

	virtual ~Fns()
	{
		_calls.clear();
	}

	void connect(std::function<void(Args...)> fct)
	{
		_calls.push_back(fct);
	}

	template<typename Object>
	void connect(Object* object, void (Object::*method)(Args...))
	{
		_calls.push_back([object,method](Args... args){(*object.*method)(args...);});
	}

	template<typename Object>
	void connect(Object* object, void (Object::*method)(Args...) const)
	{
		_calls.push_back([object,method](Args... args){(*object.*method)(args...);});
	}

	template<typename Object>
	void connect(const Object* object, void (Object::*method)(Args...) const)
	{
		_calls.push_back([object,method](Args... args){(*object.*method)(args...);});
	}

	void emit(Args... args)
	{
		for(auto call : _calls)
			call(args...);
	}
};


[cpp] view plain copy
print ?
  1. #include <cstdio>  
  2. #include "Signal.hpp"  
  3.   
  4. class Foo  
  5. {  
  6. public:  
  7.   
  8.     void bar(int x, int y)  
  9.     {  
  10.         printf("Foo::bar(%d, %d)\n", x, y);  
  11.     }  
  12. };  
  13.   
  14. void foobar(int x, int y)  
  15. {  
  16.     printf("foobar(%d, %d)\n", x, y);  
  17. }  
  18.   
  19. int main(void)  
  20. {  
  21.     Foo foo;  
  22.     Fns<int, int> s;  
  23.   
  24.     // Connect a function  
  25.     s.connect(foobar);  
  26.     // Connect a class method  
  27.     s.connect(&foo, &Foo::bar);  
  28.     // Create and connect some lambda expression  
  29.     s.connect([&foo](int x, int y){   
  30.         printf("lambda::"); foo.bar(x, y);   
  31.     });  
  32.     // Emit the signal !  
  33.     s.emit(4, 2);  
  34.     getchar();  
  35.     return 0;  
  36. }  
#include <cstdio>
#include "Signal.hpp"

class Foo
{
public:

	void bar(int x, int y)
	{
		printf("Foo::bar(%d, %d)\n", x, y);
	}
};

void foobar(int x, int y)
{
	printf("foobar(%d, %d)\n", x, y);
}

int main(void)
{
	Foo foo;
	Fns<int, int> s;

	// Connect a function
	s.connect(foobar);
	// Connect a class method
	s.connect(&foo, &Foo::bar);
	// Create and connect some lambda expression
	s.connect([&foo](int x, int y){ 
		printf("lambda::"); foo.bar(x, y); 
	});
	// Emit the signal !
	s.emit(4, 2);
	getchar();
	return 0;
}

foobar(4, 2)
Foo::bar(4, 2)
lambda::Foo::bar(4, 2)




YuHengZuo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 11 std::function和std::bind使用详解
08-25
主要介绍了C++ 11 std::function和std::bind使用详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
将成员函数转成全局函数
扶风的博客
08-30 723
我们在开发中肯定遇到过将一个成员函数经过bind，变成一个std::function,可以用来做回调等等，std::function只能在C++中使用，假如我们想将成员函数绑定到一个全局函数的，暴露其函数指针，则C以及其他好多语言，也可以受惠了。 思路是使用模板，结合bind，为每一个绑定生成一个模板类，暴露类中的static函数。代码如下： template<uint64_t id, class R, class C, class... Params, class Ptr, class Args&g
C++11新特性——std::bind参数绑定
木牛的博客
01-12 1581
据不知名人士透露，《带注释的C++参考手册》这本书对 C++ 98 标准的制定产生了很大的影响。但是是用于将已有变量绑定到可调用函数的参数上。早在C98中，就有两个函数bind1st和bind2nd，他们被用于绑定已有变量到可执行函数的第一个参数和第二个参数，相同的是他们都只能绑定一个参数。当然类的静态成员不属于任何对象，因此无须特殊的指向静态成员的指针，指向静态成员的指针与普通指针没有什么区别。这部分比较重要的就是要明白普通函数和类成员函数有什么区别，我们都知道的是在函数指针上面，类成员函数指针。
std::bind()函数的使用
休息一下接着来的博客
07-22 1849
C++11中提供了std::bind。bind()函数的意义就像它的函数名一样，是用来绑定函数调用的某些参数的。 bind的思想实际上是一种延迟计算的思想，将可调用对象保存起来，然后在需要的时候再调用。而且这种绑定是非常灵活的，不论是普通函数、函数对象、还是成员函数都可以绑定，而且其参数可以支持占位符。 bind()函数常用于，绑定回调函数。 1. bind()绑定静态函数 #include <functional> // std::bind() 函数在头文件<functional&gt
函数对象类——function
qq_43496435的博客
05-08 209
//std::function是函数的容器：装函数类型 //函数类型：返回类型（参数1类型，参数2类型，...,参数n类型） 比如：int add（double a, double b） 的函数类型就是int(double,double) //std::function是一个类 ...
C++11中lambda、std::function和std:bind详解
08-31
大家都知道C++11中增加了许多的新特性，下面在这篇文中我们就来聊一下lambda表达式，闭包，std::function以及std::bind。文中介绍的很详细，相信对大家具有一定的参考价值，有需要的朋友们下面来一起看看吧。
通过c++11的std::bind及std::function实现类方法回调，模拟Qt实现信号槽
10-06
c++11引入了std::bind及std::function，实现了函数的存储和绑定，即先将可调用的对象保存起来，在需要的时候再调用。定义了SignalObject信号类和SlotObject槽类，其中信号类中的 std::function(int)> _call就是要...
C++11中std::packaged_task的使用详解
01-20
C++11中的std::packaged_task是个模板类。std::packaged_task包装任何可调用目标(函数、lambda表达式、bind表达式、函数对象)以便它可以被异步调用。它的返回值或抛出的异常被存储于能通过std::future对象访问的共享...
std::bind()函数详解
Awesomewan的博客
03-06 7407
std::bind()函数详解
C++实现可变参数回调函数
xiaosier_D的博客
04-29 2955
利用std::function和可变参数模板实现可变参数回调注册函数
C++11 std::bind函数绑定
二进制君
12-06 3550
文章目录概念和原理普通函数的绑定占位符引入成员函数绑定 概念和原理 可将std::bind函数看作一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。 std::bind将可调用对象与其参数一起进行绑定，绑定后的结果可以使用std::function保存。std::bind主要有以下两个作用： 将可调用对象和其参数绑定成一个防函数； 只绑定部分参数，减少可调用对象传入的参数。 bind接受的第一个参数必须是一个可调用的对象f,可以是函数、函数指针、函数对象和成员
std::bind 函数参数绑定
shujianlove0的博客
11-27 2795
std::bind 可以将一个多参数的函数转化为一个少参数 或者无参数函数，上面的bind之后变为func(int value,1,5),函数签名是bool (int)了 而非 bool(int,int,int） 1.如果需要把一个类中的函数转换为全局函数签名，则std::bind(func,this); 2.静态函数可以直接绑定 bool fun(int value, int min, int ...
C++ bind-绑定一切函数
FairLikeSnow的博客
01-01 1158
bind-绑定一切函数 std::bind可以绑定一切函数 • 将函数、成员函数和闭包转成function函数对象 • 将多元(n>1)函数转成一元函数或者(n-1)元函数。 1.改变参数个数，绑定全局函数： int f(int, char, double); auto ff = bind(f, _1, 'c', 1.2); // 绑定f()函数调用的第二个和第三个参数，返回一个新的...
关于变参函数指针以及变参Function模板
陶醉鱼的博客
04-17 1334
关于变参函数指针以及变参Function模板
C++之STL std::function及std::bind总结
Lid_23的博客
07-30 996
bind第一个参数传入一个函数、函数指针、lamda表达式、类的成员函数都是可以的，这里注意，如果是类的成员函数，则需要再类的作用域前加上&，第二个占位符需要注意，如果不是类的成员函数，那么直接要么是一个参数，例如10，或者std::placeholders::_1（由调用bind返回值时传入），如果是类的成员函数，第二个参数是实例化的类对象，第三个参数开始才是函数的输入参数。也可参考std::function对于类的成员函数的调用。注：调用类成员函数时，需要和std::bind一起使用；
std::function和std::bind绑定器
ox0080的博客
10-29 587
C++11中std::function and std::bind 1. 可调用对象 C++中可调用对象的概念，有以下几种定义: 1) 是一个函数指针 2) 是一个具有operator()成员函数的类对象 3) 是一个可被转换为函数指针的类对象 4) 是一个类成员(函数)指针 void fun(void){ //... } struct Foo{ void operator()(vo...
关于std::function和std::bind绑定成员函数
热门推荐
火苗999℃的博客
07-28 1万+
关于std::bind绑定成员函数与虚函数的方法。 #include #include using namespace std; class A { public: A() :m_a(0){} ~A(){} virtual void SetA(const int& a){ cout
C++ 九阴真经之命令控制模式
零落年华的专栏
06-13 300
所谓命令控制模式，就是对应的行为进行封装，通过命令就能控制，你可以理解为linux下指令操作。 比如一个操作包括，A1、A2、.....A10这10步操作，如果某一步失败，那么就进行倒回，如果这10个操作的业务类型各不相同，并且所需要的参数也不尽相同，操作起来就比较困难，如果我能将他们全部封装成指令模式，只通过A1到A10这10个字符串就触发，那么实现起来就容易的多。 对于网络编程，命令控制就变得必不可少了，该模型可以帮你将网络层与业务层完美的管理在一起。 实...
C++中std::function与std::bind
最新发布
10-25
C++中的std::function和std::bind都是函数对象适配器，用于将函数或成员函数转换为可调用对象。其中，std::function是一个通用的函数封装，可以用于存储任何可调用对象（函数、函数指针、成员函数指针、lambda表达式...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值