boost::bind绑定成员变量，函数书嵌套

最新推荐文章于 2023-02-10 13:29:59 发布
最新推荐文章于 2023-02-10 13:29:59 发布
阅读量1.2k 收藏
点赞数
分类专栏： boost
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsz211/article/details/39157013
版权

根据原博客：http://blog.csdn.net/hengyunabc/article/details/7773250 添加成员函数绑定功能，成员变量绑定，函数嵌套

</pre><pre name="code" class="cpp"><span style="color:#333333;">#ifndef BOOST_BIND_BIND_HPP_INCLUDED__Mybind
#define BOOST_BIND_BIND_HPP_INCLUDED__Mybind

#include <iostream>
using namespace std;
namespace boost {
template<class T> struct is_placeholder {
	enum _vt {
		value = 0
	};
};
template<int I> struct arg {
	arg() {
	}
};
template<class T>
struct type {
};
namespace _bi // implementation details
{

template<class A1> struct storage1 {
	explicit storage1(A1 a1) :
			a1_(a1) {
		cout<<"storage1  storage1(A1 a1)"<<endl;
	}
	A1 a1_;
};
template<int I> struct storage1<boost::arg<I> > {
	explicit storage1(boost::arg<I>) {
		cout<<"storage1  storage1(boost::arg<I>)"<<endl;
	}
	static boost::arg<I> a1_() {
		return boost::arg<I>();
	}

};

template<int I> struct storage1<boost::arg<I> (*)()> {
	explicit storage1(boost::arg<I> (*)()) {
		cout<<"storage1  storage1(boost::arg<I> (*)())"<<endl;
	}
	static boost::arg<I> a1_() {
		return boost::arg<I>();
	}
};

// 2

template<class A1, class A2> struct storage2: public storage1<A1> {
	typedef storage1<A1> inherited;
	storage2(A1 a1, A2 a2) :
			storage1<A1>(a1), a2_(a2) {
		cout<<"storage2  storage2(A1 a1, A2 a2)"<<endl;
	}
	A2 a2_;
};

template<class A1, int I> struct storage2<A1, boost::arg<I> > : public storage1<
		A1> {
	typedef storage1<A1> inherited;
	storage2(A1 a1, boost::arg<I>) :
			storage1<A1>(a1) {
		cout<<"storage2  storage2(A1 a1, boost::arg<I>)"<<endl;
	}
	//boost::arg<I> a2_;

	static boost::arg<I> a2_() {
		return boost::arg<I>();
	}

};

template<class A1, int I> struct storage2<A1, boost::arg<I> (*)()> : public storage1<
		A1> {
	typedef storage1<A1> inherited;
	storage2(A1 a1, boost::arg<I> (*)()) :
			storage1<A1>(a1) {
		cout<<"storage2  storage2(A1 a1, boost::arg<I> (*)())"<<endl;
	}
	static boost::arg<I> a2_() {
		return boost::arg<I>();
	}
};

// result_traits
template<class R, class F> struct result_traits {
	typedef R type;
};
struct unspecified {
};
template<class F> struct result_traits<unspecified, F> {
	typedef typename F::result_type type;
};
// value
template<class T> class value {
public:
	value(T const & t) :
			t_(t) {
	}
	T & get() {
		return t_;
	}
private:
	T t_;
};
// type
template<class T> class type {
};
// unwrap
template<class F> struct unwrapper {
	static inline F & unwrap(F & f, long) {
		return f;
	}
};
// listN
class list0 {
public:
	list0() {
	}
	template<class T> T & operator[](_bi::value<T> & v) const {
		cout << "list0  T & operator[](_bi::value<T> & v)" << endl;
		return v.get();
	}
	template<class R, class F, class A> R operator()(type<R>, F & f, A &,
			long) {
		cout << "list0  R operator()(type<R>, F & f, A &, long)" << endl;
		return unwrapper<F>::unwrap(f, 0)();
	}
	template<class F, class A> void operator()(type<void>, F & f, A &, int) {
		cout << "list0  void operator()(type<void>, F & f, A &, int)" << endl;
		unwrapper<F>::unwrap(f, 0)();
	}
};

template<class A1> class list1: private storage1<A1> {
private:
	typedef storage1<A1> base_type;
public:
	explicit list1(A1 a1) :
			base_type(a1) {
	}
	A1 operator[](boost::arg<1>) const {
		return base_type::a1_;
	}
	A1 operator[](boost::arg<1> (*)()) const {
		return base_type::a1_;
	}
	template<class T> T & operator[](_bi::value<T> & v) const {
		return v.get();
	}
</span><span style="color:#ff6666;">	//template<class R, class F, class L> typename result_traits<R, F>::type operator[] (_bi::bind_t<R, F, L> & b) const { return b.eval(*this); } 这里实现函数嵌套，没有编译</span><span style="color:#333333;">
	template<class R, class F, class A> R operator()(type<R>, F & f, A & a,
			long) {
		return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
	}
//	template<class F, class A> void operator()(type<void>, F & f, A & a, int) {
//		unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
//	}
};

template<class A1, class A2> class list2: private storage2<A1, A2> {
private:
	typedef storage2<A1, A2> base_type;
public:
	list2(A1 a1, A2 a2) :
			base_type(a1, a2) {
	}
	A1 operator[](boost::arg<1> ) const {
		cout << "list2  A1 operator[](boost::arg<1>)" << endl;
		return base_type::a1_;
	}
	A2 operator[](boost::arg<2> ) const {
		cout << "list2  A1 operator[](boost::arg<2>)" << endl;
		return base_type::a2_;
	}
	
	A1 operator[](boost::arg<1> (*)()) const {
		cout << "list2  A1 operator[](boost::arg<1> (*)())" << endl;
		return base_type::a1_;
	}
	A2 operator[](boost::arg<2> (*)()) const {
		cout << "list2  A1 operator[](boost::arg<2> (*)())" << endl;
		return base_type::a2_;
	}
	
	template<class T> T & operator[](_bi::value<T> & v) const {
		cout << "T & operator[](_bi::value<T> & v)" << endl;
		return v.get();
	}
	template<class R, class F, class A> R operator()(type<R>, F & f, A & a,
			long) {
		return f(a[base_type::a1_], a[base_type::a2_]);

	}

};
// bind_t
template<class R, class F, class L> class bind_t {
public:
	void test(){
		cout << "haha test" << endl;
	}
	typedef bind_t this_type;
	bind_t(F f, L const & l) :
			f_(f), l_(l) {
	}
	typedef typename result_traits<R, F>::type result_type;
	result_type operator()() {
		cout << "bind_t::result_type operator()()" << endl;
		list0 a;
		return l_(type<result_type>(), f_, a, 0);
	}
	template<class A1> result_type operator()(A1 & a1) {
		list1<A1 &> a(a1);
		return l_(type<result_type>(), f_, a, 0);
	}	
	template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) {
		cout << "bind_t::operator(1)" << endl;
		list2<A1 &, A2 &> a(a1, a2);
		return l_(type<result_type>(), f_, a, 0);
	}
</span><span style="color:#ff6666;">/*
	template<class A> result_type eval(A & a)
	{
		return l_(type<result_type>(), f_, a, 0);
	}
*/</span><span style="color:#333333;">

private:
	F f_;
	L l_;
};

template<class T, int I> struct add_value_2 {
	typedef boost::arg<I> type;
};

template<class T> struct add_value_2<T, 0> {
	typedef _bi::value<T> type;
};
template<class T> struct add_value {
	typedef typename add_value_2<T, boost::is_placeholder<T>::value>::type type;
};
template<class T> struct add_value<value<T> > {
	typedef _bi::value<T> type;
};
template<int I> struct add_value<arg<I> > {
	typedef boost::arg<I> type;
};
//template<int I> struct add_value<arg<I> (*)()> {
//	typedef boost::arg<I> (*type)();
//};
template<class R, class F, class L> struct add_value<bind_t<R, F, L> > {
	typedef bind_t<R, F, L> type;
};
// list_av_N
template<class A1> struct list_av_1 {
	typedef typename add_value<A1>::type B1;
	typedef list1<B1> type;
};
template<class A1, class A2> struct list_av_2 {
	typedef typename add_value<A1>::type B1;
	typedef typename add_value<A2>::type B2;
	typedef list2<B1, B2> type;
};
} // namespace _bi

// function pointers
template<class R>
_bi::bind_t<R, R (*)(), _bi::list0> bind2(R (*f)()) {
	typedef R (*F)();
	typedef _bi::list0 list_type;
	return _bi::bind_t<R, F, list_type>(f, list_type());
}
template<class R, class B1, class A1>
_bi::bind_t<R, R (*)(B1), typename _bi::list_av_1<A1>::type> bind2(R (*f)(B1),
		A1 a1) {
	typedef R (*F)(B1);
	typedef typename _bi::list_av_1<A1>::type list_type;
	return _bi::bind_t<R, F, list_type>(f, list_type(a1));
}
template<class R, class B1, class B2, class A1, class A2>
_bi::bind_t<R, R (*)(B1, B2), typename _bi::list_av_2<A1, A2>::type> bind2(
		R (*f)(B1, B2), A1 a1, A2 a2) {
	typedef R (*F)(B1, B2);
	typedef typename _bi::list_av_2<A1, A2>::type list_type;
	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2));
}

template<class R, class T, class A1 > 
	class mf1
{
public:

    typedef R result_type;
    typedef T * first_argument_type;
    typedef A1 second_argument_type;

private:
    
    typedef R (T::*F)(A1);
    F f_;
public:
    
    explicit mf1(F f): f_(f) {}

    R operator()(T & p, A1 a1) 
    {
     cout << "mf1::operator(1)" << endl;
        (p.*f_)(a1);
    }
	  R operator()(T * p, A1 a1) 
    {
     cout << "mf1::operator(2)" << endl;
        (p->*f_)(a1);
    }
	  R operator()(T const & p, A1 a1) 
    {
     cout << "mf1::operator(3)" << endl;
        (p.*f_)(a1);
    }
};

template<class R, class T,  class B1,class A1, class A2>
_bi::bind_t<R, mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
bind2(	R (T::*f)(B1), A1 a1, A2 a2) 
{
	typedef mf1<R, T, B1> F;
	typedef typename _bi::list_av_2<A1, A2>::type list_type;
	return _bi::bind_t<R, F, list_type>( F(f), list_type(a1, a2));
}

template<class R, class T> class dm
{
public:

    typedef R const & result_type;
    typedef T const * argument_type;

private:
    
    typedef R (T::*F);
    F f_;

public:
    
    explicit dm(F f): f_(f) {}

    R & operator()(T * p) const
    {
        return (p->*f_);
    }

    R const & operator()(T const * p) const
    {
        return (p->*f_);
    }

    template<class U> R const & operator()(U const & u) const
    {
        return call(u, &u);
    }


    R & operator()(T & t) const
    {
        return (t.*f_);
    }

    R const & operator()(T const & t) const
    {
        return (t.*f_);
    }
};


template<class R, class T, class A1>
_bi::bind_t< R, dm<R, T>, typename _bi::list_av_1<A1>::type >
    bind2(R T::*f, A1 a1)
{
    typedef dm<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>( F(f), list_type(a1) );
}



} // namespace boost

namespace {
boost::arg<1> _1;
boost::arg<2> _2;
}
template <typename R,typename T, typename Arg>
class simple_bind_t {
  typedef R (T::*fn)(Arg);
  fn fn_;
  T t_;
public:
  simple_bind_t(fn f,const T& t):fn_(f),t_(t) {}

  R operator()(Arg& a) {
    return (t_.*fn_)(a);
  }
};
template <typename R, typename T, typename Arg>
simple_bind_t<R,T,Arg> simple_bind(
  R (T::*fn)(Arg),
  const T& t,
  const int&) {
  return simple_bind_t<R,T,Arg>(fn,t);
}
#endif // #ifndef BOOST_BIND_BIND_HPP_INCLUDED__Mybind
</span>
测试main函数： 

#include <iostream>
#include "bind.h"
using namespace std;
void tow_arguments(int i1, int i2) {
	std::cout <<"i1:"<< i1<<"\n" <<"i2:"<< i2 << '\n';
}

class Test {
public:  
	Test():init(123){}
	void do_stuff(int* i) 
	{    
		std::cout <<"1do_stuff hahahahaha:"<<"\n" ;
	}
	void do_stuff(int* i) const
	{    
		std::cout <<"2do_stuff hahahahaha:"<<"\n" ;
	}
	int init;
};
void testClass(Test t, int i){
	cout<<"testClass,Test,int"<<endl;
}
int main() {
	int i1 = 1, i2 = 2;
	Test t;
	Test* p = &t;
	int* i = &i1;
	(boost::bind2(&tow_arguments, 123, _1))(i1);
	std::cout <<"&Test::init: "<<(boost::bind2(&Test::init,p))()<<std::endl;
	(boost::bind2(&Test::do_stuff,_1, _2))(p,i);

	//(boost::bind2(&Test::do_stuff,t, _1))(i1);
	/*
	(boost::bind2(&tow_arguments, _1, _2))(i1, i2);
	(boost::bind2(&tow_arguments, _2, _1))(i1, i2);
	(boost::bind2(&tow_arguments, _1, _1))(i1, i2);

	(boost::bind2(&tow_arguments, 222, 666))(i1, i2);

	Test t;
	(boost::bind2(&testClass, _1, 666))(t, i2);
	(boost::bind2(&testClass, _1, 666))(t);
	(boost::bind2(&testClass, t, 666))();
	*/
}



dsz211
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
函数参数Boost库bind函数的嵌套调用
weixin_34200628的博客
04-22 139
查了好多资料，发现还是不全，干脆自己整理吧，至少保证在我的做法正确的，以免误导读者，也是给自己做个记录吧！      问题提出：     我写了一个函数，它要需应用一个生成整数随机数的随机数发生器作为参数。然后写了一个函数来根据参数生成不同分布的随机数发生器，供前一个函数应用。我用调了boost库的一些基于特定概率分布的随机数生成函数，但是有很多函数的结果是double型的。     我的...
bind变量
weixin_30663471的博客
05-30 111
http://www.postgresql.org/docs/9.3/static/plpgsql-statements.html#PLPGSQL-STATEMENTS-DIAGNOSTICS EXECUTE format('UPDATE tbl SET %I = $1 WHERE key = $2', colname) USING newvalue, keyvalue;...
Boost库bind函数的嵌套调用
yanxiangtianji的专栏
04-22 1776
问题提出： 我写了一个函数，它需要使用一个生成整数随机数的随机数发生器作为参数。然后写了一个函数来根据参数生成不同分布的随机数发生器，供前一个函数使用。我调用了boost库的一些基于特定概率分布的随机数生成函数，但是有很多函数的结果是double型的。 我的函数将随机数发生器定义为boost::function类型。很明显那些生成double的函数不能直接通过bind operator()的方
boost bind嵌套使用
wangzhicheng2013的专栏
03-03 163
#include <boost/bind/bind.hpp> #include <boost/array.hpp> #include <iostream> #include <string> #include <algorithm> #include <functional> #include <cassert> void sample1() { const boost::array<int, 12> .
boost中bind的使用
weixin_34004750的博客
11-03 106
1 Boost::bind 在介绍bind之前，我们先介绍一下STL中的绑定机制。我们知道在C++标准库中提供了bind1st,bind2nd函数绑定器和fun_ptr,mem_fun等函数适配器用来将函数绑定为一个函数对象。这些函数绑定器和适配器使用起来比较码分，需要根据全局函数还是类的成员函数，是一个参数还是多个参数等作出不同的选择，甚至有时候STL并不能满足我们的要求。boost...
C++中使用function和bind绑定类成员函数的方法详解
01-19
定义一个普通的类 ...输出的值是2，说明pf传进去的4并没有什么用，在bind的时候值已经绑定死了，但是pf()这样不给参数会报错。 如果我们想自定义参数，使用占位符，std::placeholders::_1，可以看
C++ 11 std::function和std::bind使用详解
08-25
std::function 可以绑定到全局函数、类静态成员函数或 lambda 表达式，而 std::bind 只能绑定到类的非静态成员函数。 在示例代码中，我们可以看到 CC_CALLBACK 系列的定义是基于 std::bind 的，用于将成员函数绑定...
boost::asio::serialport实现串口通信
02-25
配置串口参数是通过`serial_port_base`的成员函数完成的，例如设置波特率为9600： ```cpp serial.set_option(boost::asio::serial_port_base::baud_rate(9600)); ``` 其他可配置参数包括数据位(`data_bits`)...
javascript bind绑定函数代码
10-29
这个自定义`bind`函数接收两个参数：`fn`是要绑定的函数，`context`是期望的`this`上下文。如果只传入`fn`，则`bind`返回原始函数。函数内部通过`Array.prototype.slice.call(arguments, 2)`获取除`fn`和`context`...
std::bind可以绑定成员变量
MaxMaxXiong的博客
09-15 790
#include <iostream> #include <string> #include <functional> using namespace std; class MyClass { public: MyClass(){} MyClass(int a): m_i(a){} ~MyClass(){} void Get(int a, string str) { cout << a << " " << str .
C++:boost::bind的一些用法
热门推荐
Felaim的博客
10-12 1万+
没有对C++了解特别深入吧，还是对有些特性用法之类的不是很熟悉，阅读代码的时候还是碰到很多不明白。 下面是LZ读到的一句代码boost::function<const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &> f = boost::bind(&MainLoop::onNewCloud, this, _1);boost::bind的用法目的 b
boost::bind的简单实现
惜兰blog
07-08 116
boost::bind的简单实现 前言 在上一篇blog中简单的实现了boost::function，支持带有2个参数的函数/函数指针，函数对象，函数适配器/bind类，以及带有1个参数的成员函数指针。 本文接着来介绍如何实现一个简单的boost::bind。 基本目标如下： 支持接收0个参数的函数/函数指针，函数对象。 支持接收1个参数的函数/函数指针，函数对象。 支持接收2个参数的函数/函数指针，函数对象。 实现 首先，解决占位符的问题： namespace { struct Placehold
std bind 原理简单图解（清晰简明）
xiexievv的专栏
01-14 7341
本文解释了bind 是如何工作的。为了清晰，我对图中的语法作了一些简化（例如，省略函数调用操作符的参数类型），并且简化了 bind 的实现. bind 可以用来将用户提供的需要一个参数的函数转换成不需要参数的函数对象。绑定的值（在这个例子中是123）存储在函数对象内并且会被自动
function object研究之十三 result_traits
Dean Chen的专栏
12-08 2826
result_traits模板定义在bind.hpp中，属于_bi namespace中。// result_traits template struct result_traits { typedef R type; }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCT
boost::bind 绑定成员函数
dsz211的专栏
09-09 1713
#ifndef BOOST_BIND_BIND_HPP_INCLUDED__Mybind#define BOOST_BIND_BIND_HPP_INCLUDED__Mybind#include using namespace std;namespace boost {template struct is_placeholder {enum _vt {value = 0};};template st
Boost::bind使用详解
zxnzjccmily的博客
02-10 1493
boost::bind
boost::enable_if与SFINAE原则
cbNotes的专栏：不积硅步，无以至千里;不积小流，无以成江海!
12-02 1386
模板函数的重载遵循SFINAE原则（substitution-failure-is-not-an-error）：当一个模板函数的返回值或参数类型无效的时候，该实例不会参与重载解析，也不会导致编译错误。 利用这个原则，可以设计出具有选择性的模板函数。 先看一个例子： int negate(int i) { return -i; }                        
boost::bind 详解
weixin_34227447的博客
10-08 623
使用 boost::bind是标准库函数std::bind1st和std::bind2nd的一种泛化形式。其可以支持函数对象、函数、函数指针、成员函数指针，并且绑定任意参数到某个指定值上或者将输入参数传入任意位置。 1. 通过functions和function pointers使用bind 给定如下函数： 1 int f(int a, int b) 2 { 3 retur...
boost::bind绑定成员函数时，第一个参数传递对象的特殊情况
证券指标的专栏
05-17 4755
boost::bind绑定成员函数时，第一个参数传递对象的特殊情况 boost::bind(&memberfunction, obj, _1, _2........)类似这样的用法，我们叫做成员函数绑定，boost库的文档中说的很清楚，第一个参数可以是value、pointer和reference，即传值、传地址和传引用都是可以的，所以在一般情况下，下面三种使用bind的形式都是成立的。
std::bind绑定成员函数
最新发布
06-02
可以使用std::bind函数来绑定成员函数。在绑定成员函数时，需要指定对象的地址作为第一个参数，然后是成员函数的指针。例如，如果有一个类MyClass，其中有一个成员函数printMessage()，可以使用如下方式绑定该函数： ``` MyClass obj; auto func = std::bind(&MyClass::printMessage, &obj); ``` 在这个例子中，&obj是MyClass对象的地址，&MyClass::printMessage是printMessage()成员函数的指针。现在，我们可以使用func来调用printMessage()函数，就像这样： ``` func(); ``` 这将调用obj.printMessage()函数。注意，这里使用了自动类型推导auto关键字来推导func的类型，因为std::bind函数返回的类型是非常复杂的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值