boost------bind的使用(Boost程序库完全开发指南)读书笔记

bind是c++98标准库中函数适配器bind1st/bind2nd的泛化和增强，可以适配任意的可调用类型，包括函数指针、函数引用、成员函数指针和函数对象。

1、工作原理

bind并不是一个单独的类或函数，而是非常庞大的家族，依据绑定的参数个数和要绑定的调用对象类型，总共有数十个不同的形式，但它们的名字都叫做bind，编译器会根据具体的绑定代码自动确定要使用的正确形式。

bind接受的第一个参数必须是一个科调用对象f，包括函数指针、函数引用、成员函数指针和函数对象，之后bind接受最多九个参数，参数的数量必须与f的参数数量相等，这些参数将被传递给f作为形参。

绑定完成后，bind会返回一个函数对象，它内部保存了f的拷贝，具有operator()，返回值类型被自动推导为f的返回值类型。在发生调用时，这个函数对象将把之前存储的参数转发给f完成调用：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;

int f(int a, int b)
{
	return (a + b);
}

int g(int a, int b, int c)
{
	return (a + b + c);
}

typedef int (*f_type)(int, int);
typedef int (*g_type)(int, int, int);

int _tmain(int argc, _TCHAR* argv[])
{
	cout << boost::bind(f, 1, 2)() << endl;
	cout << boost::bind(g, 1, 2, 3)() << endl;

	return 0;
}

上面的例子是bind最简单的形式。bind表达式存储了func和a1、a2的拷贝，产生了一个临时函数对象。

因为func接受两个参数，而a1和a2都是实参，因此临时函数对象将具有一个午餐的operator()。当operator()调用发生函数对象把a1、a2的拷贝传递给func，完成真正的函数调用。

bind的真正威力在于它的占位符，它们分别被定义为_1、_2、_3一直到_9，位于一个匿名名字空间中。

2、绑定普通函数、绑定函数，用法相同：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;

int f(int a, int b)
{
	return (a + b);
}

int g(int a, int b, int c)
{
	return (a + b + c);
}

typedef int (*f_type)(int, int);
typedef int (*g_type)(int, int, int);

int _tmain(int argc, _TCHAR* argv[])
{
	cout << boost::bind(f, 1, 2)() << endl;
	cout << boost::bind(g, 1, 2, 3)() << endl;

	// 使用占位符
	int x = 1, y = 2, z = 3;
	cout << boost::bind(f, _1, 2)(x) << endl;
	cout << boost::bind(f, _1, _2)(x, y) << endl;
	cout << boost::bind(g, _1, 2, 3)(x) << endl;
 	cout << boost::bind(g, _1, _2, 3)(x, y) << endl;
 	cout << boost::bind(g, _1, _2, _3)(x, y, z) << endl;

	// 重点看这个 _2的位置是按照后面参数来匹配的2号位置也就是y的位置
 	cout << boost::bind(g, x, _2, z)(x, y) << endl;
	cout << boost::bind(g, x, _3, z)(z, x, y) << endl;

	return 0;
}

3、绑定成员函数

类的成员函数不同于普通函数，因为成员函数指针不能直接使用operator()，它必须被绑定到一个对象或指针，然后才能得到this指针进而调用成员函数。

因此bind需要“牺牲”一个占位符的位置，要求用户提供一个类的实例、引用或者指针，通过对象作为第一个参数来调用成员函数：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;

struct demo
{
	int f(int a, int b)
	{
		return (a + b);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	demo a, &ra = a;
	demo *p = &a;

	int x = 1, y = 2;
 	cout << boost::bind(&demo::f, a, _1, _2)(x, y) << endl;
	cout << boost::bind(&demo::f, &ra, _1, _2)(x, y) << endl;
	cout << boost::bind(&demo::f, *p, _1, _2)(x, y) << endl;

	return 0;
}

注意：我们必须在成员函数前加上取地址操作符&，表明这是一个成员函数指针，否则会无法通过编译，这是与绑定函数的一个小小的不同。

bind能够绑定成员函数，这是个非常有用的功能，它可以替代标准库中令人迷惑的mem_fun和mem_fun_ref绑定器，用来配合标准算法操作容器中的对象。

下面的代码使用bind搭配标准算法for_each用来调用容器中所有对象的Print函数：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;
#include "vector"

struct point
{
	int x, y;
	point(int a = 9, int b = 9) : x(a), y(b)
	{

	}

	void Print()
	{
		cout << "x value is : " << x << " y value is : " << y << endl;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	vector<point> v(10);

	for_each(v.begin(), v.end(), bind(&point::Print, _1));

	return 0;
}

bind同样支持帮顶虚拟成员函数，用法与非虚拟函数相同，虚函数的行为将由实际调用发生时的实例来决定。

4、绑定成员变量

bind的另一个对类的操作是他可以绑定public成员变量，就像一个选择器，用法与绑定成员函数类似，只需要把成员变量名像一个成员函数一样去使用：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;
#include "string"

struct point
{
	int x, y;
	point(int a = 9, int b = 9) : x(a), y(b)
	{

	}

	void Print()
	{
		cout << "x value is : " << x << " y value is : " << y << endl;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	point pt(1, 99);
	typedef pair<int , string> pait_t;
	pait_t p(886, "zengraoli");

	cout << boost::bind(&point::y, pt)() << endl;
	cout << boost::bind(&pait_t::first, p)() << endl;
	cout << boost::bind(&pait_t::second, p)() << endl;

	return 0;
}

5、绑定函数对象

如果函数对象有内部定义result_type，那么bind可以自动推导出返回值类型，用法与绑定普通函数一样。但如果函数对象没有定义result_type，则需要在绑定形式上做一点改动，用模板参数指明返回值类型，标准库和Boost库中的大部分函数对象都具有result_type定义，因此不需要特别的形式就可以直接使用bind：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;
#include <functional>

struct f
{
	int operator()(int a, int b)
	{
		return (a + b);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	cout << boost::bind(plus<int>(), _1, _2)(10, 20) << endl;; // 执行x + y
	cout << boost::bind<int>(f(), _1, _2)(10, 20) << endl;

	return 0;
}

这样的写法boost::bind<int>(f(),_1,_2)(10,20)多少有不方便，因此，在编写自己的函数对象时，最后遵循规范为他们增加内部typedef result_type，这将使函数对象与许多其他标准库和Boost库组件良好配合工作。

6、使用ref库

bind采用拷贝的方式存储绑定对象和参数，这意味着绑定表达式中的每个变量都会有一份拷贝，如果函数对象或值参数很大、拷贝代价很高，或者无法拷贝，那么bind的使用就会受到限制。

因此bind库可以搭配ref库使用，ref库包装了对象的引用，可以让bind存储对象引用的拷贝，从而降低了拷贝的代价。但这也带来了一个隐患，因为有时候bind的调用可能会延后很久，程序员必须保证bind被调用时引用是有效的。如果调用时引用的变量或者函数对象被销毁了，那么会发生未定义行为。

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;

int g(int a, int b, int c)
{
	return (a + b + c);
}

struct f
{
	int operator()(int a, int b)
	{
		return (a + b);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	int x = 10;
	cout << boost::bind(g, _1, boost::cref(x), boost::ref(x))(10) << endl;

	// 因为重载了operator() 所以目前f为一个函数对象
	f af;
	cout << boost::bind<int>(boost::ref(af), _1, _2)(10, 20) << endl;

	{
		BOOST_AUTO(r, boost::ref(x));
		int *y = new int(99);
		r = boost::ref(*y);
		cout << r << endl;

		cout << boost::bind(g, r, 1, 1)() << endl;
		if (y)
		{
			delete y;
		}
		// 下面的代码 因为引用失效，引发了未定义的行为
		cout << boost::bind(g, r, 1, 1)() << endl;
	}

	return 0;
}

7、高级议题

为占位符更名：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;

struct f
{
	int operator()(int a, int b)
	{
		return (a + b);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	boost::arg<1> &_x = _1;
	boost::arg<2> &_y = _2;

	f af;
	cout << boost::bind<int>(boost::ref(af), _x, _y)(10, 20) << endl;

	return 0;
}

定义别名也可以使用BOOST_AUTO，这样就无需关心占位符的真实类型，把类型推导的工作交给编译器，有利于编写可移植的代码：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;

struct f
{
	int operator()(int a, int b)
	{
		return (a + b);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	BOOST_AUTO(&_x, _1);
	BOOST_AUTO(&_y, _2);

	f af;
	cout << boost::bind<int>(boost::ref(af), _x, _y)(10, 20) << endl;

	return 0;
}

嵌套绑定

bind可以嵌套，一个bind表达式生成的函数对象可以被另一个bind再绑定，从而实现类似f(g(x))的形式：

#include "stdafx.h"
#include "boost/utility/result_of.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/assign.hpp"
#include "boost/ref.hpp"
#include "boost/bind.hpp"
#include "iostream"
using namespace std;

int g(int a, int b)
{
	return (a + b);
}

int f(int a, int b)
{
	return (a + b);
}

int _tmain(int argc, _TCHAR* argv[])
{
	int x = 10;
	int y = 20;
	cout << boost::bind(f, boost::bind(g, _1, _2), _2)(x, y) << endl;

	return 0;
}

使用bind的嵌套用法必须小心，它不太容易一次写正确，也不太容易理解，超过两个以上的bind表达式通常只能被编译器读懂。