这是一种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 的插槽的一种类型。通过连接到不同的插槽组,你可以预设调用插槽的顺序,同时也可以断开插槽组。
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);
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();
}
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();
}
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();
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的对象不用关心是谁在监听消息,这种耦合度比较低的。