Doubango 刚刚推出了“世界上第一个Html5 SIP客户端”：SipML5，实现了基于Chrome的SIP客户端，并与自己先前的开源产品Idoubs和IMSDroid实现互通。就像主页里的两个Demo视频显示的一样，你可以轻松实现Chrome和IOS/Android移动设备之间的实时视音频通话。

SipML5使用Chrome的实验功能WebRTC实现媒体功能，并用Javascript封装了一个完整强大的Javascript SIP/SDP stack 完成信令的管理，传输层通过Websocket与服务端Gateway通信接入SIP Server，最终通过Video TAG播放视音频内容。

于是:

Html5 + Websocket + Javascript SIP/SDP stack + WebRTC Media Stack

=> World's first HTML5 SIP client

大家可以去体验一下喽~ http://www.sipml5.org/

正则表达式用途甚广，各种语言脚本都兼容标准的正则表达式，下面总结基本符号和语法，做复习备忘之用。

元字符

重复

字符类

我们可以轻松地指定一个字符范围，像[0-9]代表的含意与\d就是完全一致的：一位数字；同理[a-z0-9A-Z_]也完全等同于\w（如果只考虑英文的话）。

分枝条件

分枝条件指的是有几种规则，如果满足其中任意一种规则都应该当成匹配，具体方法是用”|“把不同的规则分隔开。

Example：0\d{2}-\d{8}|0\d{3}-\d{7}这个表达式能匹配两种以连字号分隔的电话号码：一种是三位区号，8位本地号(如010-12345678)，一种是4位区号，7位本地号(0376-2233445)。

分组

可以用小括号“（）”来指定子表达式(也叫做分组)，然后你就可以指定这个子表达式的重复次数了，你也可以对子表达式进行其它一些操作(后面会有介绍)。

(\d{1,3}\.){3}\d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式，请按下列顺序分析它：\d{1,3}匹配1到3位的数字，(\d{1,3}\.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次，最后再加上一个一到三位的数字(\d{1,3})。

反义

例子：\S+匹配不包含空白符的字符串。

<a[^>]+>匹配用尖括号括起来的以a开头的字符串。

众所周知，多态是面向对象编程语言的重要特性，它允许基类的指针或引用指向派生类的对象，而在具体访问时实现方法的动态绑定。C++ 和 Java 作为当前最为流行的两种面向对象编程语言，其内部对于多态的支持到底是如何实现的呢，本文对此做了全面的介绍。

注意到在本文中，指针和引用会互换使用，它们仅是一个抽象概念，表示和另一个对象的连接关系，无须在意其具体的实现。

Java 的实现方式

Java 对于方法调用动态绑定的实现主要依赖于方法表，但通过类引用调用和接口引用调用的实现则有所不同。总体而言，当某个方法被调用时，JVM 首先要查找相应的常量池，得到方法的符号引用，并查找调用类的方法表以确定该方法的直接引用，最后才真正调用该方法。以下分别对该过程中涉及到的相关部分做详细介绍。

JVM 的结构

典型的 Java 虚拟机的运行时结构如下图所示

图 1.JVM 运行时结构
 

此结构中，我们只探讨和本文密切相关的方法区 (method area)。当程序运行需要某个类的定义时，载入子系统 (class loader subsystem) 装入所需的 class 文件，并在内部建立该类的类型信息，这个类型信息就存贮在方法区。类型信息一般包括该类的方法代码、类变量、成员变量的定义等等。可以说，类型信息就是类的 Java 文件在运行时的内部结构，包含了改类的所有在 Java 文件中定义的信息。

注意到，该类型信息和 class 对象是不同的。class 对象是 JVM 在载入某个类后于堆 (heap) 中创建的代表该类的对象，可以通过该 class 对象访问到该类型信息。比如最典型的应用，在 Java 反射中应用 class 对象访问到该类支持的所有方法，定义的成员变量等等。可以想象，JVM 在类型信息和 class 对象中维护着它们彼此的引用以便互相访问。两者的关系可以类比于进程对象与真正的进程之间的关系。

Java 的方法调用方式

Java 的方法调用有两类，动态方法调用与静态方法调用。静态方法调用是指对于类的静态方法的调用方式，是静态绑定的；而动态方法调用需要有方法调用所作用的对象，是动态绑定的。类调用 (invokestatic) 是在编译时刻就已经确定好具体调用方法的情况，而实例调用 (invokevirtual) 则是在调用的时候才确定具体的调用方法，这就是动态绑定，也是多态要解决的核心问题。

JVM 的方法调用指令有四个，分别是 invokestatic，invokespecial，invokesvirtual 和 invokeinterface。前两个是静态绑定，后两个是动态绑定的。本文也可以说是对于 JVM 后两种调用实现的考察。

常量池（constant pool）

常量池中保存的是一个 Java 类引用的一些常量信息，包含一些字符串常量及对于类的符号引用信息等。Java 代码编译生成的类文件中的常量池是静态常量池，当类被载入到虚拟机内部的时候，在内存中产生类的常量池叫运行时常量池。

常量池在逻辑上可以分成多个表，每个表包含一类的常量信息，本文只探讨对于 Java 调用相关的常量池表。

CONSTANT_Utf8_info

字符串常量表，该表包含该类所使用的所有字符串常量，比如代码中的字符串引用、引用的类名、方法的名字、其他引用的类与方法的字符串描述等等。其余常量池表中所涉及到的任何常量字符串都被索引至该表。

CONSTANT_Class_info

类信息表，包含任何被引用的类或接口的符号引用，每一个条目主要包含一个索引，指向 CONSTANT_Utf8_info 表，表示该类或接口的全限定名。

CONSTANT_NameAndType_info

名字类型表，包含引用的任意方法或字段的名称和描述符信息在字符串常量表中的索引。

CONSTANT_InterfaceMethodref_info

接口方法引用表，包含引用的任何接口方法的描述信息，主要包括类信息索引和名字类型索引。

CONSTANT_Methodref_info

类方法引用表，包含引用的任何类型方法的描述信息，主要包括类信息索引和名字类型索引。

图 2. 常量池各表的关系
 

可以看到，给定任意一个方法的索引，在常量池中找到对应的条目后，可以得到该方法的类索引（class_index）和名字类型索引 (name_and_type_index), 进而得到该方法所属的类型信息和名称及描述符信息（参数，返回值等）。注意到所有的常量字符串都是存储在 CONSTANT_Utf8_info 中供其他表索引的。

方法表与方法调用

方法表是动态调用的核心，也是 Java 实现动态调用的主要方式。它被存储于方法区中的类型信息，包含有该类型所定义的所有方法及指向这些方法代码的指针，注意这些具体的方法代码可能是被覆写的方法，也可能是继承自基类的方法。

如有类定义 Person, Girl, Boy,

清单 1

				
 class Person { 
 public String toString(){ 
    return "I'm a person."; 
	 } 
 public void eat(){} 
 public void speak(){} 
	
 } 

 class Boy extends Person{ 
 public String toString(){ 
    return "I'm a boy"; 
	 } 
 public void speak(){} 
 public void fight(){} 
 } 

 class Girl extends Person{ 
 public String toString(){ 
    return "I'm a girl"; 
	 } 
 public void speak(){} 
 public void sing(){} 
 } 

当这三个类被载入到 Java 虚拟机之后，方法区中就包含了各自的类的信息。Girl 和 Boy 在方法区中的方法表可表示如下：

图 3.Boy 和 Girl 的方法表
 

可以看到，Girl 和 Boy 的方法表包含继承自 Object 的方法，继承自直接父类 Person 的方法及各自新定义的方法。注意方法表条目指向的具体的方法地址，如 Girl 的继承自 Object 的方法中，只有 toString() 指向自己的实现（Girl 的方法代码），其余皆指向 Object 的方法代码；其继承自于 Person 的方法 eat() 和 speak() 分别指向 Person 的方法实现和本身的实现。

Person 或 Object 的任意一个方法，在它们的方法表和其子类 Girl 和 Boy 的方法表中的位置 (index) 是一样的。这样 JVM 在调用实例方法其实只需要指定调用方法表中的第几个方法即可。

如调用如下：

清单 2

				
 class Party{ 
…
 void happyHour(){ 
 Person girl = new Girl(); 
 girl.speak(); 
…
	 } 
 } 

当编译 Party 类的时候，生成 girl.speak()的方法调用假设为：

Invokevirtual #12

设该调用代码对应着 girl.speak(); #12 是 Party 类的常量池的索引。JVM 执行该调用指令的过程如下所示：

图 4. 解析调用过程
 

JVM 首先查看 Party 的常量池索引为 12 的条目（应为 CONSTANT_Methodref_info 类型，可视为方法调用的符号引用），进一步查看常量池（CONSTANT_Class_info，CONSTANT_NameAndType_info ，CONSTANT_Utf8_info）可得出要调用的方法是 Person 的 speak 方法（注意引用 girl 是其基类 Person 类型），查看 Person 的方法表，得出 speak 方法在该方法表中的偏移量 15（offset），这就是该方法调用的直接引用。

当解析出方法调用的直接引用后（方法表偏移量 15），JVM 执行真正的方法调用：根据实例方法调用的参数 this 得到具体的对象（即 girl 所指向的位于堆中的对象），据此得到该对象对应的方法表 (Girl 的方法表 )，进而调用方法表中的某个偏移量所指向的方法（Girl 的 speak() 方法的实现）。

接口调用

因为 Java 类是可以同时实现多个接口的，而当用接口引用调用某个方法的时候，情况就有所不同了。Java 允许一个类实现多个接口，从某种意义上来说相当于多继承，这样同样的方法在基类和派生类的方法表的位置就可能不一样了。

清单 3

				
interface IDance{ 
   void dance(); 
 } 

 class Person { 
 public String toString(){ 
   return "I'm a person."; 
	 } 
 public void eat(){} 
 public void speak(){} 
	
 } 

 class Dancer extends Person 
 implements IDance { 
 public String toString(){ 
   return "I'm a dancer."; 
	 } 
 public void dance(){} 
 } 

 class Snake implements IDance{ 
 public String toString(){ 
   return "A snake."; 
	 } 
 public void dance(){ 
 //snake dance 
	 } 
 } 

图 5.Dancer 的方法表（查看大图）
 

可以看到，由于接口的介入，继承自于接口 IDance 的方法 dance（）在类 Dancer 和 Snake 的方法表中的位置已经不一样了，显然我们无法通过给出方法表的偏移量来正确调用 Dancer 和 Snake 的这个方法。这也是 Java 中调用接口方法有其专有的调用指令（invokeinterface）的原因。

Java 对于接口方法的调用是采用搜索方法表的方式，对如下的方法调用

invokeinterface #13

JVM 首先查看常量池，确定方法调用的符号引用（名称、返回值等等），然后利用 this 指向的实例得到该实例的方法表，进而搜索方法表来找到合适的方法地址。

因为每次接口调用都要搜索方法表，所以从效率上来说，接口方法的调用总是慢于类方法的调用的。

回页首

C++ 的实现方式

从上文可以看到，Java 对于多态的实现依赖于方法表，但比较特殊的是，对于接口的支持是非常不同的，每次调用都要搜索方法表。实际上，在 C++ 中，单继承时对于多态的实现非常类似于 Java，但由于支持多重继承，这会碰到和 Java 支持接口动态调用同样的问题，C++ 的解决方案是利用对象的多个方法表指针，不幸的是，这会引入额外的指针调整的复杂性。

单继承

单继承时，C++ 对于多态的实现本质上与 Java 是一样的，也是基于方法表。但 C++ 在编译时就可以确认要调用的方法在方法表中的位置，而没有 JVM 在方法调用时查询常量池的过程。

C++ 编译时，编译器会自动做很多工作，其中之一就是在需要时在对象插入一个变量 vptr 指向类的方法表。如 Person,、Girl 的类定义与上文中 Java 类似，若

清单 4

				
class Person{ 
	 . . . 
 public : 
    Person (){} 
    virtual ~Person (){}; 
    virtual void speak (){}; 
    virtual void eat (){}; 
 }; 

class Girl : public Person{ 
	 . . . 
   public : 
   Girl(){} 
   virtual ~Girl(){}; 
   virtual void speak(){}; 
   virtual void sing(){}; 
 }; 

则 Person 与 Girl 实例的内存对象模型为：

图 6.Person 与 Girl 的对象模型
 

如下的调用代码

 Person *p = new Girl(); 
 p->speak(); 
 p->eat(); 

经编译器编译后调用代码为：

 p->vptr[1](p); 
 p->vptr[2](p); 

这样在运行时，会自然的过渡到对 Girl 的相应函数的调用。

可以看到方法表中没有各自的构造函数，这是因为 C++ 的方法表中仅含有用 virtual 修饰的方法，非 virtual 的方法是静态绑定的，没有必要占用方法表的空间。这与 Java 是不同的，Java 的方法表含有类所支持的所有的方法，可以说，Java 类的所有方法都是”virtual”（动态绑定）的。

多重继承

多重继承下，情况就完全不一样了，因为两个不同的类，其继承自与同一个基类的方法，在各自的方法表中的位置可能不同（和 Java 中的接口情况类似），但 Java 在运行时有 JVM 的支持，C++ 在这里引入了多个指向方法表的指针来解决这个问题，由此带来了调整指针位置的额外复杂性。

若有如下关系的三个类，Engineer 继承自 Person 和 Employee

图 7. 类静态结构关系图
 

Engineer 实例对象模型为：

图 8.Engineer 对象模型
 

可以看到 Engineer 实例有两个指向方法表的指针，这是与 Java 大不相同的。

设有如下的代码 ,

清单 5

				
 Engineer *p = new Engineer(); 
 Person * p1 = (Person *)p; 
 Empolyee *p2 = (Employee *)p; 

则各指针在运行时分别指向各自的子对象，如下所示：

图 7.Engineer 实例
 

C++ 中对象的指针总是指向对象的起始处，如上述代码中，p 是 Engineer 对象的起始地址，而 p1 指向 p 转型成 Person 子对象的指针，可以看到实际上，两者是相等的；但 Employee 子对象的指针 p2 则于 p 和 p1 不同，实际上

 p2 = p + sizeof(Person); 
 p1->eat(); 
 p2->work(); 

则编译后生成的调用代码为：

 *(p1->vptr1[i]) (p1) 
 *(p2->vptr2[j]) (p2) 

某些情况下，甚至需要将 this 指针调整到整个对象的起始处，如：

 delete p2; 

析构函数的 this 指针要被调整到 p 所指向的位置，否则则会出现内存泄漏。设析构函数在方法表中的位置为 0，则编译后为：

 *(p2->vptr2[0]) (p) 

对于指针的调整，编译器没有足够的知识在编译时刻完成这个任务。如上例中，对于 p2 所指向的对象，该对象类型可能是 Employee 或任何该类的子类 ( 其它的子类如 Teacher 等 )，编译器无法确切的知道 p2 和整个对象的初始地址的距离 (offset), 这样的调整只能发生在运行时刻。

一般有两种方法来调整指针，如下图：

图 8. 指针调整 - 扩展方法表
 

这种方法将指针所有调整的 offset 存储于方法表的每个条目中，当调用方法表中的方法时，首先利用 offset 的值完成指针调整再做实际的调用。缺点显而易见，增加了方法表的大小，而且并不是每个方法都需要做指针调整。

图 9. 指针调整 -thunk 技术
 

这就是所谓的 thunk 技术，方法表的每个条目指向一小段汇编代码，这段代码来保证做指针调整和调用正确的方法，相当于加了一层抽象。

回页首

多态在 Java 和 C++ 中的实现比较

上文分别对于多态在 Java 和 C++ 中的实现做了比较详细的介绍，下面对这两种语言的多态实现的异同做个小结：

• 单继承情况下，两者实现在本质上相同，都是使用方法表，通过方法表的偏移量来调用具体的方法。

• Java 的方法表中包含 Java 类所定义的所有实例方法，而 C++ 的方法表则只包含需要动态绑定的方法 (virtual 修饰的方法 )。这样，在 Java 下所有的实例方法都要通过方法表调用，而 C++ 中的非虚方法则是静态绑定的。

• 任意 Java 对象只 “指向”一个方法表，而 C++ 在多重继承下则可能指向多个方法表，编译器保证这多个方法表的正确初始化。

• 多层继承中 C++ 面临的主要问题是 this 指针的调整，设计更精巧更复杂；而 Java 在接口调用时完全采用搜索的方式，实现更直观，但调用效率比实例方法调用要慢许多。

可以看到，两者之间既有相似之处，也有不同的地方。对于单继承的实现本质上是一样的，但也有细微的差别（如方法表）；差别最大的是对于多重继承（多重接口）的支持。实际上，由于 C++ 是静态编译型语言，它无法像 Java 那样，在运行时刻动态的“查找”所要调用的方法。

参考资料

学习

• Java 虚拟机规范：Java 虚拟机规范规定了 Java 的具体工作方式，对 Java 语言的各个方面做了全面的阐述。 
  
  
• Java 虚拟机专题：Java 虚拟机（Java virtual machine，JVM）是语言与底层软件和硬件之间的一种转换器。Java 语言的所有实现都必须实现 JVM，从而使 Java 程序可以在有 JVM 的任何系统上运行。 
  
  
• 深入 Java 虚拟机：对 Java 虚拟机的各种可能实现做了独到而清晰的解析。 
  
  
• 深入 C++ 对象模型：深入探讨了 C++ 的对象模型，函数调用机制等，对编译器在幕后所做的工作给出了详尽的解释。 
  
  
• 技巧：用 C 语言实现程序的多态性：使用 C 语言模拟简单的多态特性，该文给出了一个简单的实现。 
  
  
• developerWorks Java 技术专区：这里有数百篇关于 Java 编程各个方面的文章。 

转自：http://www.ibm.com/developerworks/cn/java/j-lo-polymorph/index.html

一直在搞WebRTC，发现其Web API还很不成熟，Chrome的团队也在不停地fix bug，于是下载了WebRTC的源码学习。WebRTC的源码一部分已经merge进了libjingle项目，结构比较复杂。

libjingle里面有一个基类为has_slots，搜索了一下其资料发现是一个很好用的C++库。开源库连接：http://sourceforge.jp/projects/sfnet_sigslot/

下面是转载的别人的资料，一个对sigslot简单清晰的介绍,学习分享一下！

1.    简介

sigslot是一个线程安全、类型安全，用C++实现的sig/slot机制(sig/slot机制就是对象之间发送和接收消息的机制)的开源代码库。是一个非常好用的库,只有一个头文件sigslot.h。

2.    Sigslot实例

现代的C++项目通常包含大量的C++类和对象，对象之间通过成员函数调用，缺点是当类和对象规模很大时，相互之间必须记住对方提供了哪些接口，以及接口的详细信息，很不方便。

比如：我们有一个switch类和一个light类，而我们现在需要将两者关联起来，即通过switch控制light的状态，我们可能需要添加一个另外的类ToggleSwitch来将两者关联起来：

class Switch

{

public:

     virtual void Clicked() = 0;

};

class Light

{

public:

     void ToggleState();

     void TurnOn();

     void TurnOff();

};

class ToggleSwitch : public Switch

{

public:

     ToggleSwitch(Light& lp){m_lp = lp;}

     virtual void Clicked(){m_lp.ToggleState();}

private:

     Light& m_lp;

};

Light lp1, lp2;

ToggleSwitch tsw1(lp1), tsw2(lp2);

这在功能上完全可以实现，但想象一下如果大量的需要相互交互消息的类，那工作量就不是一般的大了。

使用sig/slot机制来解决上述情况，不需要关心关联类的接口细节，sigslot实现的switch和light上述功能如下：

class Switch

{

public:

     signal0<> Clicked;

};

class Light : public has_slots<>

{

public:

     void ToggleState();

     void TurnOn();

     void TurnOff();

};

Switch sw1, sw2;

Light lp1, lp2;

     Sigslot机制实现该功能与第一种方法相比，switch类多了个signal0成员，light类需要从has_slots<>继承，其他没有什么变化，但省去了编写继承类用来实现两者关联的ToggleSwitch。

下面是实现功能的简单代码。

#include <iostream>

using namespace std;

#include "sigslot.h"

using namespace sigslot; //必须加上sigslot的命名空间

//在用vs调试时还需要将sigslot.h中很多的自定义模板结构类型前加typename

const int TRUE = 1;

const int FALSE = 0;

class Switch

{

public:

    signal0<> Clicked;

//这里的信号是不带参数的，signaln表示带几个参数

};

class Light : public has_slots<>

{

public:

Light(bool state){b_state = state;Displaystate();}

       void ToggleState(){b_state = !b_state;Displaystate();} //作为消息的响应

       void TurnOn(){b_state = TRUE;Displaystate();}

       void TurnOff(){b_state = FALSE;Displaystate();}

       void Displaystate(){cout<<"The state is "<<b_state<<endl;}

private:

       bool b_state;

};

void main()

{

       Switch sw1, sw2,all_on,all_off;

       Light lp1(TRUE), lp2(FALSE);

       sw1.Clicked.connect(&lp1,&Light::ToggleState); //绑定

       sw2.Clicked.connect(&lp2,&Light::ToggleState);

       all_on.Clicked.connect(&lp1,&Light::TurnOn);

       all_on.Clicked.connect(&lp2,&Light::TurnOn);

       all_off.Clicked.connect(&lp1,&Light::TurnOff);

       all_off.Clicked.connect(&lp2,&Light::TurnOff);

       sw1.Clicked();

       sw2.Clicked();

       all_on.Clicked();

       all_off.Clicked();

       sw1.Clicked.disconnect(&lp1);

       sw2.Clicked.disconnect(&lp2);

       all_on.Clicked.disconnect(&lp1);

       all_on.Clicked.disconnect(&lp2);

       all_off.Clicked.disconnect(&lp1);

all_off.Clicked.disconnect(&lp2);

}

3.    参数类型

sig/slot可以带参数也可以不带，最多可以带8个参数。重新回顾上例，switch类的signal0<> Clicked,称之为sig，即用来发出信号；而继承has_slots<>的类light的成员函数void ToggleState() Turnon() Turnoff(),称之为slot,即信号的处理函数。 sigslot的核心就在这里，就是通过这两个建立对应关系来实现对象间的消息交互。

sig是一个成员变量，它形如

signal+n<type1,type2……>

    后面的n表示signal可以接收几个参数，类型任意，最多为8个。这是由库中指定的，当然如果实际开发需要更多的参数，可以修改sigslot库。

slot是一个成员函数，它形如：

void SlotFunction(type1,type2……)

   需要记住：slot的类必须继承has_slots<>;成员函数的返回值必须为void类型，这是这个库的局限性，当然如果实际开发需要返回值，也是可以修改sigslot库来实现。此外还需要注意的是slot的原形需要与sig一致。怎么说呢，就是signal只能与带有与它相同参数个数的slot函数进行绑定，而且signal的参数是直接传递给slot的。

4.    Sigslot库用法

发送信号

信号(sig，即sig/slot的sig，下面提到的信号等同于此含义)：

signal1<char *, int> ReportError;

比如上面的一个ReportError这个信号，当调用ReportError("Something went wrong", ERR_SOMETHING_WRONG);时候，将自动调用ReportError的emit成员函数发出一个信号。发给谁呢？

连接信息号

通过调用sig的connect函数建立sig和slot间的对应关系。Connect函数接收两个参数，一个是消息目的对象的地址(指针)，另一个是目的对象的成员函数指针(slot)。为了让整个机制有效运行，目的类必须从has_slots<>继承，并且sig/slot参数类型必须一致。也可以将一个sig连接到多个slot上，这样每次sig发出信号的时候，每个连接的slot都能收到该信号。

断开信号连接

通过调用sig的disconnect函数断开sig和slot之间的连接，只有一个参数：目的对象的地址。一般不需要显式调用disconnect函数，在sig类和目的类(包含slot函数的类)析构函数中将自动调用disconnect断开sig和slot的连接。也可使用disconnect_all断开该sig的所有slot。

all_on.Clicked.connect(&lp1,&Light::TurnOn);

all_on.Clicked.connect(&lp2,&Light::TurnOn);//同上

all_on.Clicked.disconnect_all();

5.    Sigslot库范例

在开发一个复杂工程的时候，经常会遇到这样一个问题：整个系统被分成数个模块，每个模块提供有限的功能，由上层调用组成整个系统，为了保证每个模块的独立性，我们经常会尽量限制模块与模块之间的直接联系，比如每个模块只提供有限的API或者COM接口，而内部实现则完全封闭起来。
    但有的时候会出一些设计要求，必须能够使模块之间能够直接通讯，而这两个模块往往处于不同的逻辑层次，之间相差甚远，如何设计它们之间的调用模式使整个工程维持整洁变得非常困难，比如模块直接直接包含对方的头文件会引起编译变得复杂，提供api或者接口会引起版本危机等问题。
    sigslot的出现为我们提供了一种解决问题的思想，它用“信号”的概念实现不同模块之间的传输问题，sigslot本身类似于一条通讯电缆，两端提供发送器和接收器，只要把两个模块用这条电缆连接起来就可以实现接口调用，而sigslot本身只是一个轻量级的作品，整个库只有一个.h文件，所以无论处于何种层次的库，都可以非常方便的包含它。

    举个例子，我们设计一个发送消息的类，这个类负责在某种时刻向外界发出求救信号

// Class that sends the notification.
class Sender
{
public:
    // The signal declaration.
    // The ’2′ in the name indicates the number of parameters. Parameter types
    // are declared in the template parameter list.
    sigslot::signal2<std::string ,int >SignalDanger;
   
    // When anyone calls Panic(), we will send the SignalDanger signal.
    void Panic()
    {
        SignalDanger("Help!",0);
     }
};

另外一个类则负责接收求助信号

// Listening class. It must inherit sigslot.
class Receiver :public sigslot::has_slots<>
{
public:
    // When anyone calls Panic(), Receiver::OnDanger gets the message.
    // Notice that the number and type of parameters match
    // those in Sender::SignalDanger, and that it doesn’t return a value.
    void OnDanger(std::string message,int time)
    {
        printf("I heard something like\"%s\" at %d!\n",message.c_str(),time);
    }
};

现在让我们在主逻辑中把这两个类连接起来

Sender sender;
Receiver receiver;
 
// Receiver registers to get SignalDanger signals.
// When SignalDanger is sent, it is caught by OnDanger().
// Second parameter gives address of the listener function class definition.
// First parameter points to instance of this class to receive notifications.
sender.SignalDanger.connect(&receiver,Receiver::OnDanger);

只要在任何时候调用 sender.Panic()函数，就会把求救信号发送给接收者，而且这两个发送和接收端的模块都可以独立编译，不会出现版本问题。

static_cast