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

C++11 std::bind std::function 高级用法 (c++11的新特性)

原文：https://blog.csdn.net/yangjie6898862/article/details/44282037

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

<strong>/*
* 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;
}
</strong>

<strong>/*
* 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;
}
</strong>

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 <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...);
}
};

#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)

C++11 std::bind std::function 高级用法相关推荐

C++11 std::function, std::bind, std::ref, std::cref
C++11 std::function, std::bind, std::ref, std::cref 转自:http://www.jellythink.com/ std::function 看看这段 ...
【C++】C++11的std::function和std::bind用法详解
在设计回调函数的时候,无可避免地会接触到可回调对象.在C++11中,提供了std::function和std::bind两个方法来对可回调对象进行统一和封装. 可调用对象 C++中有如下几种可调用对象 ...
std::function和std::bind
std::function和std::bind std::function 可调用对象是一个函数指针是一个具有operator()成员函数的类和对象可被转换成函数指针的类对象: 一个类成员函数指 ...
函数对象，lamdda表达式，function函数包装，std::bind函数绑定
一函数对象在学习其他知识之前,先来学习函数对象,然后引出std::lambda.std::function.std::bind等内容的学习,那么究竟什么是函数对象呢? 函数对象(Function ...
【C++】char uchar string stringstream queue array vector set map std::function std::bind
文章目录 cout 防止使用科学计数法一维数组的三种初始化方法二维数组 vector作为参数的三种传参方式 vector 的 reserve resize set std::map std::pa ...
c++11 std::bind与std::function
function模板类和bind模板函数,使用它们可以实现类似函数指针的功能,但却比函数指针更加灵活,特别是函数指向类的非静态成员函数时. std::function可以绑定到全局函数/类静态成 ...
std::function和std::bind用法
std::bind() std::bind 主要用于绑定生成目标函数,一般用于生成的回调函数,cocos的回退函数都是通过std::bind和std::function实现的.两个点要明白: 1.绑定 ...
C++11新特性之std::function std::bind
std::function 在c++98&03时我们通常使用回调函数来处理一些需要某种场景下才触发的回调操作,但回调函数有一个限制就是它只能赋值给同类型的全局或者静态函数,对于其他有相同的返回 ...
C++11 FAQ中文版：std::function 和 std::bind
std::function 和 std::bind 标准库函数bind()和function()定义于头文件中(该头文件还包括许多其他函数对象),用于处理函数及函数参数.bind()接受一个函数(或者 ...

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

C++11 std::bind std::function 高级用法相关推荐

最新文章

热门文章