boost signals

 

n Signals实现了信息源和某些对这些信息的变化感兴趣的实例之间的一对多关系。

   这是一种Observer的设计模式，允许同一信号对应多个处理。

   包含很多Slot，Slot是信号接受者。

template<typename Signature,
   typename Combiner = last_value<R>,
  typename Group = int,
  typename GroupCompare = std::less<Group>,
  typename SlotFunction = function<Signature> >
class signal : public signals::trackable, private noncopyable {

 }

Signature  被调用的函数原型， signal<double(int)>

Combiner  表示一个函数对象，它负责逐个对该 signal 所有已连接的插槽(slot)进行调用。它同时也决定如何将组合这些调用返回的结果。

Groups  组合所有连接到 signal 的插槽的一种类型。通过连接到不同的插槽组，你可以预设调用插槽的顺序，同时也可以断开插槽组。

 

 

n 成员函数

   signals::connection connect(const slot_type& s);

   signals::connection connect(const Group& g, const slot_type& s);

   void disconnect(const Group& g);

   std::size_t num_slots() const;

   result_type operator()(T1, T2, ..., TN);

 

 

n普通函数 和函数对象

void my_first_slot() { std::cout << "void my_first_slot()/n"; }

class my_second_slot {
public:
    void operator()() const {
    std::cout << "void my_second_slot::operator()() const/n";
    }
};

int main() {
    boost::signal<void ()> sig;
    sig.connect(&my_first_slot);
    sig.connect(my_second_slot());
    std::cout << "Emitting a signal.../n";
    sig();
}

 

 

n 插槽分组

int main() {
    boost::signal<void ()> sig;
    sig.connect(0， &my_first_slot);
    sig.connect(1， my_second_slot());   

    std::cout << "Emitting a signal.../n";
    sig();

}

 

 

n 管理连接，如何断开连接

 some_slot_type sc1("sc1");
 boost::signals::connection c1=sig.connect(sc1);

 

 if (c1.connected())
     std::cout << "c1 is connected to a signal/n";

 

 c1.disconnect();

 

 

n 成员函数怎用作为Slot连接

class some_class {
public:
    bool some_function(double d) { return d>3.14; }
    bool another_function(double d) { return d<0.0; }
};

int main() {
    boost::signal<bool (double)> sig0;
    boost::signal<bool (double)> sig1;

    some_class sc;

    sig0.connect( boost::bind(&some_class::some_function, &sc,  _1));
    sig1.connect( boost::bind(&some_class::another_function, &sc, _1));

    sig0(3.1);
    sig1(-12.78);
}

 

Bind 通过创建函数对象来绑定到一个函数(普通函数或成员函数)。

 

 

Signal的好处是，发送Signal的对象不用关心是谁在监听消息，这种耦合度比较低的。