波奇学C++：function包装器和智能指针(一)

function包装器

相当于适配器，用于对可调用对象（函数指针，仿函数，lambda）进行封装，使得他们的类型统一。

double func(double d)
{
	return d / 4;
}
struct func1
{
	double operator()(double d)
	{
		return d / 4;
	}
};
int main()
{
    function<double(double)> f1 = [](double d) {return d / 4; };
    function<double(double)> f2 = func;
    function<double(double)> f3 = func1();
    return 0;
}

function<return-type(parameter-type)> = lambda/函数指针/仿函数匿名对象

包装后的对象可以放在容器中，并调用。

vector<function<double(double)>> v = { f1,f2,f3 };
for (auto e : v)
{
	cout << e(4) << endl;
}

functional 的 bind绑定

bind绑定

从传参的角度对封装好的可调用对象进一步限制

改变参数对应位置

int Sub(int a, int b)
{
	return a - b;
}


function<int(int, int)> rSub = bind(Sub, placeholders::_1,placeholders::_2);
cout << rSub(10, 5) << endl; // 5
function<int(int, int)> rrSub = bind(Sub, placeholders::_2, placeholders::_1);
cout << rrSub(10, 5) << endl; // -5

rSub的10 对应_1,_1对应a

rrS 的 10 对应_1,  _1 对应b

减少传参

int Add(int a, int b,int rate)
{
	return (a - b)*rate;
}
function<int(int, int)> radd = bind(Add, placeholders::_1, placeholders::_2,10);
cout << radd(10, 5) << endl; //（10-5）*10

 Add经过封装后参数只剩下a,b，rate的值被限定成10

function<int(int, int)> radd = bind(Add, placeholders::_1, 10,placeholders::_2);
cout << radd(10, 5) << endl; // 0

由此可见，bind里面的_1,_2 和函数是以相对位置映射的，而调用时radd的参数顺序和_1数字编号有关和位置顺序无关。

bind绑定类域中的函数

class A
{
public:
	static int add(int a, int b)
	{
		return a + b;
	}
	int aadd(int a, int b)
	{
		return a + b;
	}
};

function<int(int,int)> rfunc1 = bind(&A::add, placeholders::_1, placeholders::_2); 
// 静态成员函数
A a; 
function<int(int, int)> rfunc2 = bind(&A::aadd,&a, placeholders::_1, placeholders::_2);
function<int(int, int)> rfunc3 = bind(&A::aadd, A(), placeholders::_1, placeholders::_2);
// 成员函数实际三个参数，this,因此我们可以传对象指针或者匿名对象

bind的第一个参数实际上是函数地址，底层上bind绑定是仿函数。

智能指针

利用类对象的构造和析构函数来控制指针的生成和释放，即RAII

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		cout << "delete pointer"<<_ptr << endl;
	}
private:
	T* _ptr;
};
void test()
{
	SmartPtr<string> ptr(new string());
}

当test函数结束时，会调用析构函数释放指针。

智能指针的重载符号

class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	~SmartPtr()
	{
		cout << "delete pointer"<<_ptr << endl;
	}
private:
	T* _ptr;
};