C++11 std::bind std::function 高级用法 (c++11的新特性)
发布日期:2022-03-03 10:44:06 浏览次数:1 分类:技术文章

本文共 5125 字,大约阅读时间需要 17 分钟。

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


/*  * File:   main.cpp * Author: Vicky.H * Email:  eclipser@163.com */#include 
    
     #include 
     
      #include 
      
       #include 
       
        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;}
/*  * File:   main2.cpp * Author: Vicky.H * Email:  eclipser@163.com */#include 
    
     #include 
     
      void sayHello() {
      
std::cout << "Hello world !" << std::endl;}int sum(int i, int j, int k) {
return i + j + k;}template  class Func {public:
Func(T fun) {
if (!fun) {
throw "fun nullptr";
}
_fun = fun;
}
template
R Call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
return _fun(a1, a2, a3, a4, a5);
}
template
R Call(A1 a1, A2 a2, A3 a3, A4 a4) {
return _fun(a1, a2, a3, a4);
}
template
R Call(A1 a1, A2 a2, A3 a3) {
return _fun(a1, a2, a3);
}
template
R Call(A1 a1, A2 a2) {
return _fun(a1, a2);
}
template
R Call(A1 a1) {
return _fun(a1);
}
template
R Call() {
return _fun();
}
void Call() {
_fun();
}private:
T _fun;};#include  template class Fn {public:
Fn(std::function  fun) : _fun(fun) {
}
R operator()(Args... args) {
return _fun(args...);
}private:
std::function  _fun;};/* * 将函数注册到对象中,通过对象直接调用 */int main(void) {
Func  sayHelloFunc(sayHello);
sayHelloFunc.Call();
Func  sumFunc(sum);
std::cout << "sumFunc.Call (1, 2, 3) : " << sumFunc.Call (1, 2, 3) << std::endl;
std::cout << "\n---------------------------" << std::endl;
Fn<> sayHelloFn(sayHello);
sayHelloFn();
Fn  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
这篇文章中,无法直接调用脚本函数类,有了好的解决办法。这个我将随后补充。


#include 
   
    #include 
    
     template
     
      class Fns{private:
      
std::list  > _calls;public:
virtual ~Fns()
{
_calls.clear();
}
void connect(std::function  fct)
{
_calls.push_back(fct);
}
template
void connect(Object* object, void (Object::*method)(Args...))
{
_calls.push_back([object,method](Args... args){(*object.*method)(args...);});
}
template
void connect(Object* object, void (Object::*method)(Args...) const)
{
_calls.push_back([object,method](Args... args){(*object.*method)(args...);});
}
template
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...);
}};
#include 
   
    #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  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)

转载地址:https://blog.csdn.net/yangjie6898862/article/details/44282037 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:摘自windows程序设计第五版
下一篇:设计一个只能在堆上或栈上实例化的类

发表评论

最新留言

逛到本站,mark一下
[***.36.148.237]2022年07月28日 02时46分38秒

关于作者

    喝酒易醉,品茶养心,人生如梦,品茶悟道,何以解忧?唯有杜康!
-- 愿君每日到此一游!

最新文章

浮点数据类型 2021-07-01
EasyX和Windows库函数实现音乐播放 2021-07-01
EasyX图形库常用操作 2021-07-01
开发板通过NTS挂载在PC机中的文件夹 2021-07-01
配置交叉编译工具链 2019-04-28 04:22:16
C#控制台程序生成文件分析 2019-04-28 04:22:15
Visual Studio常用快捷键 2019-04-28 04:22:15
.NET平台相关概念(简单了解) 2019-04-28 04:22:15
格式化字符串的几种方式 2019-04-28 04:22:14
预处理指令的开始和结束 2019-04-28 04:22:14
#和##运算符 2019-04-28 04:22:14
java中的stack类和C++中的stack类的区别 2019-04-28 04:22:11
include的两种形式、CPP的搜索路径 2019-04-28 04:22:10
gzip、bzip2和tar 2019-04-28 04:22:10
which和whereis 2019-04-28 04:22:09
file 2019-04-28 04:22:09
grep 2019-04-28 04:22:09
内存泄露检测工具--VisualC++ debugger 和 CRT 库 2019-04-28 04:22:08
find 2019-04-28 04:22:08
vi常用命令汇总 2019-04-28 04:22:07