关闭

boost之路四 事件处理

364人阅读 评论(0) 收藏 举报
分类:


虽然这个库的名字乍一看好象有点误导,但实际上并非如此。 Boost.Signals 所实现的模式被命名为 '信号至插槽' (signal to slot),它基于以下概念:当对应的信号被发出时,相关联的插槽即被执行。 原则上,你可以把单词 '信号' 和 '插槽' 分别替换为 '事件' 和 '事件处理器'。 不过,由于信号可以在任意给定的时间发出,所以这一概念放弃了 '事件' 的名字。

因此,Boost.Signals 没有提供任何类似于 '事件' 的类。 相反,它提供了一个名为 boost::signal 的类,定义于 boost/signal.hpp. 实际上,这个头文件是唯一一个需要知道的,因为它会自动包含其它相关的头文件。

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

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

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

int main() 
{ 
  boost::signal<void ()> s; 
  s.connect(func); 
  s(); 
} 

boost::signal 实际上被实现为一个模板函数,具有被用作为事件处理器的函数的签名,该签名也是它的模板参数。 在这个例子中,只有签名为 void () 的函数可以被成功关联至信号 s

函数 func() 被通过 connect() 方法关联至信号 s。 由于 func() 符合所要求的 void () 签名,所以该关联成功建立。因此当信号 s 被触发时,func() 将被调用。

信号是通过调用 s 来触发的,就象普通的函数调用那样。 这个函数的签名对应于作为模板参数传入的签名:因为 void () 不要求任何参数,所以括号内是空的。

调用 s 会引发一个触发器,进而执行相应的 func() 函数 - 之前用 connect() 关联了的。

同一例子也可以用 Boost.Function 来实现。

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

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

int main() 
{ 
  boost::function<void ()> f; 
  f = func; 
  f(); 
} 

和前一个例子相类似,func() 被关联至 f。 当 f 被调用时,就会相应地执行 func()。 Boost.Function 仅限于这种情形下适用,而 Boost.Signals 则提供了多得多的方式,如关联多个函数至单个特定信号,示例如下。

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

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

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

int main() 
{ 
  boost::signal<void ()> s; 
  s.connect(func1); 
  s.connect(func2); 
  s(); 
} 

boost::signal 可以通过反复调用 connect() 方法来把多个函数赋值给单个特定信号。 当该信号被触发时,这些函数被按照之前用 connect() 进行关联时的顺序来执行。

另外,执行的顺序也可通过 connect() 方法的另一个重载版本来明确指定,该重载版本要求以一个 int 类型的值作为额外的参数。

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

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

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

int main() 
{ 
  boost::signal<void ()> s; 
  s.connect(1, func2); 
  s.connect(0, func1); 
  s(); 
} 

和前一个例子一样,func1()func2() 之前执行。

要释放某个函数与给定信号的关联,可以用 disconnect() 方法。

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

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

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

int main() 
{ 
  boost::signal<void ()> s; 
  s.connect(func1); 
  s.connect(func2); 
  s.disconnect(func2); 
  s(); 
} 

这个例子仅输出 Hello,因为与 func2() 的关联在触发信号之前已经被释放。

除了 connect()disconnect() 以外,boost::signal 还提供了几个方法。

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

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

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

int main() 
{ 
  boost::signal<void ()> s; 
  s.connect(func1); 
  s.connect(func2); 
  std::cout << s.num_slots() << std::endl; 
  if (!s.empty()) 
    s(); 
  s.disconnect_all_slots(); 
} 

num_slots() 返回已关联函数的数量。如果没有函数被关联,则 num_slots() 返回0。 在这种特定情况下,可以用 empty() 方法来替代。 disconnect_all_slots() 方法所做的实际上正是它的名字所表达的:释放所有已有的关联。

看完了函数如何被关联至信号,以及弄明白了信号被触发时会发生什么事之后,还有一个问题:这些函数的返回值去了哪里? 以下例子回答了这个问题。

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

int func1() 
{ 
  return 1; 
} 

int func2() 
{ 
  return 2; 
} 

int main() 
{ 
  boost::signal<int ()> s; 
  s.connect(func1); 
  s.connect(func2); 
  std::cout << s() << std::endl; 
} 

func1()func2() 都具有 int 类型的返回值。 s 将处理两个返回值,并将它们都写出至标准输出流。 那么,到底会发生什么呢?

以上例子实际上会把 2 写出至标准输出流。 两个返回值都被 s 正确接收,但除了最后一个值,其它值都会被忽略。 缺省情况下,所有被关联函数中,实际上只有最后一个返回值被返回。

你可以定制一个信号,令每个返回值都被相应地处理。 为此,要把一个称为合成器(combiner)的东西作为第二个参数传递给 boost::signal

#include <boost/signal.hpp> 
#include <iostream> 
#include <algorithm> 

int func1() 
{ 
  return 1; 
} 

int func2() 
{ 
  return 2; 
} 

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); 
  } 
}; 

int main() 
{ 
  boost::signal<int (), min_element<int> > s; 
  s.connect(func1); 
  s.connect(func2); 
  std::cout << s() << std::endl; 
} 

合成器是一个重载了 operator()() 操作符的类。这个操作符会被自动调用,传入两个迭代器,指向某个特定信号的所有返回值。 以上例子使用了标准 C++ 算法 std::min_element() 来确定并返回最小的值。

不幸的是,我们不可能把象 std::min_element() 这样的一个算法直接传给 boost::signal 作为一个模板参数。 boost::signal 要求这个合成器定义一个名为 result_type 的类型,用于说明 operator()() 操作符返回值的类型。 由于在标准 C++ 算法中缺少这个类型,所以在编译时会产生一个相应的错误。

除了对返回值进行分析以外,合成器也可以保存它们。

#include <boost/signal.hpp> 
#include <iostream> 
#include <vector> 
#include <algorithm> 

int func1() 
{ 
  return 1; 
} 

int func2() 
{ 
  return 2; 
} 

template <typename T> 
struct min_element 
{ 
  typedef T result_type; 

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

int main() 
{ 
  boost::signal<int (), min_element<std::vector<int> > > s; 
  s.connect(func1); 
  s.connect(func2); 
  std::vector<int> v = s(); 
  std::cout << *std::min_element(v.begin(), v.end()) << std::endl; 
} 

这个例子把所有返回值保存在一个 vector 中,再由 s() 返回。


4.3. 连接 Connections

函数可以通过由 boost::signal 所提供的 connect()disconnect() 方法的帮助来进行管理。 由于 connect() 会返回一个类型为 boost::signals::connection 的值,它们可以通过其它方法来管理。

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

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

int main() 
{ 
  boost::signal<void ()> s; 
  boost::signals::connection c = s.connect(func); 
  s(); 
  c.disconnect(); 
} 

boost::signaldisconnect() 方法需要传入一个函数指针,而直接调用 boost::signals::connection 对象上的 disconnect() 方法则略去该参数。

除了 disconnect() 方法之外,boost::signals::connection 还提供了其它方法,如 block()unblock()

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

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

int main() 
{ 
  boost::signal<void ()> s; 
  boost::signals::connection c = s.connect(func); 
  c.block(); 
  s(); 
  c.unblock(); 
  s(); 
} 

以上程序只会执行一次 func()。 虽然信号 s 被触发了两次,但是在第一次触发时 func() 不会被调用,因为连接 c 实际上已经被 block() 调用所阻塞。 由于在第二次触发之前调用了 unblock(),所以之后 func() 被正确地执行。

除了 boost::signals::connection 以外,还有一个名为 boost::signals::scoped_connection 的类,它会在析构时自动释放连接。

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

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

int main() 
{ 
  boost::signal<void ()> s; 
  { 
    boost::signals::scoped_connection c = s.connect(func); 
  } 
  s(); 
} 

因为连接对象 c 在信号触发之前被销毁,所以 func() 不会被调用。

boost::signals::scoped_connection 实际上是派生自 boost::signals::connection 的,所以它提供了相同的方法。它们之间的区别仅在于,在析构 boost::signals::scoped_connection 时,连接会自动释放。

虽然 boost::signals::scoped_connection 的确令自动释放连接更为容易,但是该类型的对象仍需要管理。 如果在其它情形下连接也可以被自动释放,而且不需要管理这些对象的话,就更好了。

#include <boost/signal.hpp> 
#include <boost/bind.hpp> 
#include <iostream> 
#include <memory> 

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

int main() 
{ 
  boost::signal<void ()> s; 
  { 
    std::auto_ptr<world> w(new world()); 
    s.connect(boost::bind(&world::hello, w.get())); 
  } 
  std::cout << s.num_slots() << std::endl; 
  s(); 
} 

以上程序使用 Boost.Bind 将一个对象的方法关联至一个信号。 在信号触发之前,这个对象就被销毁了,这会产生问题。 我们不传递实际的对象 w,而只传递一个指针给 boost::bind()。 在 s() 被实际调用的时候,该指针所引向的对象已不再存在。

可以如下修改这个程序,使得一旦对象 w 被销毁,连接就会自动释放。

#include <boost/signal.hpp> 
#include <boost/bind.hpp> 
#include <iostream> 
#include <memory> 

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

int main() 
{ 
  boost::signal<void ()> s; 
  { 
    std::auto_ptr<world> w(new world()); 
    s.connect(boost::bind(&world::hello, w.get())); 
  } 
  std::cout << s.num_slots() << std::endl; 
  s(); 
} 

如果现在再执行,num_slots() 会返回 0 以确保不会试图调用已销毁对象之上的方法。 仅需的修改是让 world 类继承自 boost::signals::trackable。 当使用对象的指针而不是对象的副本来关联函数至信号时,boost::signals::trackable 可以显著简化连接的管理。

0
0
查看评论

Boost-事件处理 Boost.Signals

一、概述     相信大家在听到术语“事件处理”时就会想到GUI:点击一下某个按钮,相关联的功能就会被执行。点击本身就是事件,而功能就是相对应的事件处理器。     当然这一模式的使用当然不仅限于GUI。一般情况下,任意对象都可...
  • u011676589
  • u011676589
  • 2013-08-31 17:17
  • 1044

Boost学习系列4-事件处理(上)

一、概述    相信大家在听到术语“事件处理”时就会想到GUI:点击一下某个按钮,相关联的功能就会被执行。点击本身就是事件,而功能就是相对应的事件处理器。    当然这一模式的使用当然不仅限于GUI。一般情况下,任意对象都可以调用基于特定事...
  • JuanA1
  • JuanA1
  • 2011-07-28 22:38
  • 4476

boost事件处理

很多开发者在听到术语'事件处理'时就会想到GUI:点击一下某个按钮,相关联的功能就会被执行。 点击本身就是事件,而功能就是相对应的事件处理器。 这一模式的使用当然不仅限于GUI。 一般情况下,任意对象都可以调用基于特定事件的专门函数。 本章所介绍的 Boost.Signals 库提...
  • shuyun123456789
  • shuyun123456789
  • 2014-05-14 05:26
  • 1865

boost 事件处理

目录 4.1 概述4.2 信号 Signals4.3 连接 Connections4.4 练习  该书采用 Creative Commons License 授权 A new edition of this book is available!...
  • llambkin
  • llambkin
  • 2013-05-07 09:39
  • 588

Boost 的事件管理架構:Signal / Slot(下)

原帖: http://viml.nchc.org.tw/blog/paper_info.php?CLASS_ID=1&SUB_ID=1&PAPER_ID=229 關於 Boost 的 signals2 這個函式庫,在第一篇的時候是在針對他做說明,以及列了一些最簡單的...
  • yacper
  • yacper
  • 2012-09-28 14:24
  • 2113

围棋AI之路(五)自然选择过程

上次一个网友建议我用遗传算法,不过当时我没有找到合适的遗传因子,其实根本原因是我那时候正在手工测试程序的棋力,我自己和程序下,发现问题,然后看看怎么改进。这个过程中其实带有太强的主观色彩了,直到一周前我正式摒弃了UCG的想法,我才终于决定用自然选择的方式来测试程序的棋力。摒弃UCG前面的文章中提到过...
  • oyd
  • oyd
  • 2009-01-10 23:41
  • 14365

SDL学习笔记四(事件处理)

游戏主要就是互动,没有互动的游戏跟电影有什么区别。。。 于是我们就得处理许多相关的事件,键盘按下或放开,鼠标移动,单击。。。。 用事件来驱动游戏的运行,SDL提供了很方便的函数可以处理程序中的事件,事件定义为一个多种事件的联合SDL_Event,下面这个函数可以取回事件队列中的第一个事件: i...
  • fp_hzq
  • fp_hzq
  • 2013-04-29 14:04
  • 2139

系统架构师成长之路(一)

系统架构师是近几年来在国内外迅速成长并发展良好的一个职业,它对系统开发和信息化建设的重要性及给IT业所带来的影响是不言而喻的。做为一个职场新人,如何发展成为架构师,架构师都需要具备哪些素质?
  • sunlei1980
  • sunlei1980
  • 2016-05-07 19:23
  • 6767

2018干货,成为架构师的四阶段资料分享。

本文分享的架构师资料会很多。写在分享前,我们今天聊一下IT职业发展的问题,篇幅较以往或许有点长,也掇中痛点,请用心看心去。我作为工作好些年的老司机,将带你洞穿你的IT技术未来之路该怎么走,同时会授予你一套架构真经。职业发展瓶颈?也许你现在已经工作好些年了,大把的年轻还干着初级的活。或许你已经是中高级...
  • t4i2b10X4c22nF6A
  • t4i2b10X4c22nF6A
  • 2018-01-10 00:00
  • 829

PyQt5的学习之路(四)

绝对定位#!/usr/bin/python # -*- coding: utf-8 -*-import sys from PyQt5.QtWidgets import QWidget, QApplication, QLabelclass Myform(QWidget): def __init...
  • wukai_std
  • wukai_std
  • 2017-01-16 14:51
  • 638
    个人资料
    • 访问:145606次
    • 积分:3885
    • 等级:
    • 排名:第9712名
    • 原创:304篇
    • 转载:47篇
    • 译文:0篇
    • 评论:17条
    文章分类
    最新评论