boost中signal库使用引例

#include <boost/bind.hpp>
#include <boost/signal.hpp>
#include <iostream>
#include <numeric>
#include <map>

struct cpp
{
  void operator()(void)
  {
    std::cout<<"hello,cpp"<<std::endl;
  }
};

class ppc
{
public:
  void operator()(void)
  {
    std::cout<<"hello,ppc"<<std::endl;
  }
};

void print(void)
{
  std::cout<<"hello,world"<<std::endl;
}

void time_two(int value)
{
  std::cout<<value*value<<std::endl;
}

void time_three(int value)
{
  std::cout<<value*value*value<<std::endl;
}

class super;

class doc
{
public:
  typedef boost::signal0<void>::slot_function_type T;
  void connect(const std::string& class_name, T fun, T function, super* class_address)
  {
    _signal.connect(1,fun);
    _name_connect[class_name] = _signal.connect(function);   
    std::cout<<class_address<<std::endl;
  }

  void disconnect(const std::string& class_name)
  {
    _name_connect[class_name].disconnect();
  }

  void emit_signal(void)
  {
    _signal();
  }

  void list_class(void)
  {
    list_class_name(_name_connect);
  }

private:
  template <typename container>
  void list_class_name(container& conn)
  {
    typename container::iterator it;
    for (it = conn.begin(); it != conn.end(); ++it)
      {
    std::cout<<it->first<<std::endl;
      }
  }
  boost::signal0<void> _signal;
  std::map<std::string, boost::signals::connection> _name_connect;
};

class super
{
public:
  super(const std::string& data, doc& doc):_doc(doc),_data(data)
  {
    _doc.connect(this->get_name(), boost::bind(&super::get_name, this), boost::bind(&super::print, this), this);
    _data += "super";
   
  }

  virtual void print(void)const
  {
    std::cout<<_data<<std::endl;
  }

  virtual std::string get_name(void)const
  {
    return std::string("super");
  }
 
  virtual ~super()
  {
  }
private:
  super(const super& src);
  const super& operator= (const super& rhs);

  doc& _doc;
  std::string _data;
};

class sub:public super
{
public:
  sub(const std::string& data, doc& doc):super(data,doc),_data(data)
  {
    std::cout<<this<<std::endl;
    std::cout<<this->get_name()<<std::endl;
    this->_data += "sub";
  }
 
  virtual std::string get_name(void)const
  {   
    return std::string("sub");
  }
  virtual void print(void)const
  {
    std::cout<<_data<<std::endl;
  }
private:
  sub(const sub& src);
  const sub& operator=(const sub& rhs);

  std::string _data;
};

class three:public sub
{
public:
  three(const std::string& data, doc& doc):sub(data, doc)
  {
    this->_data += "three";
  }

  virtual std::string get_name(void)const
  {
    return std::string("three");
  }
  virtual void print(void)const
  {
    std::cout<<this->_data<<std::endl;
  }

  virtual void print(void)
  {
    std::cout<<"this is override"<<std::endl;
  }
private:
  three(const three& src);
  const three& operator=(const three& rhs);

  std::string _data;
};
int main(int argc, char* argv[])
{
  boost::signal0<void> my_signal;

  my_signal.connect(2,print);
  my_signal.connect(0,cpp());
  my_signal.connect(ppc());
  my_signal();

  boost::signal1<void,int> one_signal;
  one_signal.connect(time_two);
  one_signal.connect(time_three);
 
  one_signal(10);

  doc this_doc;
  //super my_super("hello,world",this_doc);
  //sub my_sub("yijunjun",this_doc);

  three my_three("this is ", this_doc);
 
  this_doc.emit_signal();
  //this_doc.list_class();
  std::cout<<&my_three<<std::endl;//<<&my_sub<<std::endl;
  return 0;
}