boost教程（四）：事件处理

每一部分都单独注释的，运行时取消注释，将其他部分注释起来就可以。

第一部分 ：信号

#include <boost/signals2.hpp> 
/*

Boost.Signals 定义了其它一些类，位于 boost::signals 名字空间中。 
由于 boost::signal 是最常被用到的类，所以它是位于名字空间 boost 中的。
*/


#include <iostream> 
#include "boost/function.hpp"
#include <algorithm> 
#include <boost/optional/optional_io.hpp>
#include <vector>

void func()
{
	std::cout << "Hello, world!" << std::endl;
}


void func1()
{
	std::cout << "Hello" << std::flush;
}

void func2()
{
	std::cout << ", world!" << std::endl;
}

int func3()
{
	return 1;
}

int func4()
{
	return 2;
}

//返回值合成器，重载了operator()() ，返回最小值,
template <typename T>
struct min_element
{
	typedef T result_type;

	template <typename InputIterator>
	T operator()(InputIterator first, InputIterator last) const
	{
		return *std::min_element(first, last);
	}
};

//合成器保存结果
template <typename T>
struct element
{
	typedef T result_type;

	template <typename InputIterator>
	T operator()(InputIterator first, InputIterator last) const
	{
		return T(first, last);
	}
};


int test0()
{
	只有签名为 void () 的函数可以被成功关联至信号 s。
	//boost::signals2::signal<void()> s;
	函数的签名对应于作为模板参数传入的签名：因为 void () 不要求任何参数，所以括号内是空的。
	//s.connect(func);
	//s();



	//和前一个例子相类似，func() 被关联至 f。 当 f 被调用时，就会相应地执行 func()。 
	/*boost::function<void()> f;
	f = func;
	f();*/


	/*
	Boost.Signals 则提供了多得多的方式，如关联多个函数至单个特定信号，示例如下。

	*/
	/*boost::signals2::signal<void()> s;
	s.connect(func1);
	s.connect(func2);
	s();*/


	/*
	 当该信号被触发时，这些函数被按照之前用 connect() 进行关联时的顺序来执行。
	执行的顺序也可通过 connect() 方法的另一个重载版本来明确指定，
	该重载版本要求以一个 int 类型的值作为额外的参数。
	*/
	/*boost::signals2::signal<void()> s;
	s.connect(1,func2);
	s.connect(0,func1);*/
	//释放函数
	//s.disconnect(func2);
	//关联函数的数量
	//std::cout << s.num_slots() << std::endl;
	//if (!s.empty())
	//	s();
	释放所有函数
	//s.disconnect_all_slots();
	
	

	/*
	#include <boost/optional/optional_io.hpp>
	//缺省情况下，所有被关联函数中，实际上只有最后一个返回值被返回。
	*/
	/*boost::signals2::signal<int()> s;
	s.connect(func3);
	s.connect(func4);
	std::cout << s() << std::endl;*/


	//用合成器返回最小值
	/*boost::signals2::signal<int(),min_element<int>> s;
	s.connect(func3);
	s.connect(func4);
	std::cout << s() << std::endl;
*/

	//将结果保存在vector中
	boost::signals2::signal<int(), element<std::vector<int>>> s;
	s.connect(func3);
	s.connect(func4);
	std::vector<int> v = s();

	system("pause");
	return 0;
}

第二部分：连接

#include <boost/signals2.hpp> 
#include <iostream>

#include"boost/signals2/signal.hpp"
#include <boost/bind.hpp>
#include <memory>


void func5()
{
	std::cout << "Hello, world!" << std::endl;
}

class world
{
public:
	void hello() const
	{
		std::cout << "Hello, world!" << std::endl;
	}
};

class world1 :
	public boost::signals2::trackable
{
public:
	void hello() const
	{
		std::cout << "Hello, world!" << std::endl;
	}
};

int main()
{
	boost::signals2::signal<void()> s;
	/*
	函数可以通过由 boost::signals2所提供的 connect() 和 disconnect() 方法的帮助来进行管理。
	 connect() 会返回一个类型为boost::signals2::connection 的值，它们可以通过其它方法来管理。
	*/
	//boost::signals2::connection c = s.connect(func5);
	//boost::signals2::shared_connection_block cb(c);
	阻塞
	//cb.block();
	//s();
	打开阻塞
	//cb.unblock();
	//s();
	c.disconnect();



	//{
	//	//它会在析构时自动释放连接。所以不会执行下面的
	//boost::signals2::scoped_connection c = s.connect(func5);
	//}
	//s();




	//{
	//	// 在 s() 被实际调用的时候，该指针所引向的对象已不再存在。
	//	//但是还在往下执行
	//	std::auto_ptr<world> w(new world());
	//	s.connect(boost::bind(&world::hello,w.get()));
	//}

	//std::cout << s.num_slots() << std::endl;
	//s();





	//修改这个程序，使得一旦对象 w 被销毁，连接就会自动释放。

	{
		std::auto_ptr<world1> w(new world1());
		s.connect(boost::bind(&world1::hello, w.get()));
	}
	/*
	num_slots() 会返回 0 以确保不会试图调用已销毁对象之上的方法。
	仅需的修改是让 world 类继承自 boost::signals::trackable。
	*/
	std::cout << s.num_slots() << std::endl;
	s();




	system("pause");
	return 0;
}