信号和槽的使用

/*
   功能，Sigslot入门
   日期，2012年9月1日 星期六
   环境，win7-32-vs2010
   */
#include <iostream>
#include <stdio.h>
#include <pthread.h>
#include "sigslot.h"

using namespace std;
using namespace sigslot;

class ThreadMutex 
{
    private:
    pthread_mutex_t mtx;
    public:
    ThreadMutex()
    {
        pthread_mutex_init(&mtx,NULL);
    }
    ~ThreadMutex()
    {
        pthread_mutex_destroy( &mtx );
    }
    inline void lock()
    {
        pthread_mutex_lock( &mtx );
    }
    inline void unlock()
    {
        pthread_mutex_unlock( &mtx );
    }
};

class Location
{
    private:
        //pthread_t threadmy;
    public:
        // 在这里指定信号，这里的信号是不带参数的，signaln表示带几个参数，后面将会用
        // 这个信号与指定的槽进行绑定的。
        signal0<> ToSniffer;
        Location()
        {
            printf("Location is started!\n"); 
        }
        void startLoc()
        {
            cout << "开始11" << endl;
            ToSniffer();
            sleep(1);
            cout << "结束11" << endl;
        }
};
class Topocation
{
    private:
        //pthread_t threadmy;
    public:
        // 在这里指定信号，这里的信号是不带参数的，signaln表示带几个参数，后面将会用
        // 这个信号与指定的槽进行绑定的。
        signal0<> ToSniffer;
        Topocation()
        {
            printf("Topocation is started!\n"); 
        }
        void startTopo()
        {
            cout << "开始2" << endl;
            ToSniffer();
            sleep(1);
            cout << "结束2" << endl;
        }

        // 继承 has_slots<> ，表示拥有响应信号的槽
};
class Sniffer : public has_slots<>
{
    public:
        Sniffer()
        {
        }
        // 作为信号响应的槽
        void startSniffer()
        {
            m_tx.lock();
            cout << "开始探测！ " << b_state << endl;
            sleep(3);
            cout <<"探测结束" << endl;
            m_tx.unlock();
        }
    private:
        bool b_state;
        ThreadMutex m_tx;
};
class Control
{
    private:
        pthread_t mythread;
    public:
        Sniffer mysniffer;
        Location myLoc;
        Topocation myTopo;
        Control()
        {
            myLoc.ToSniffer.connect(&mysniffer,&Sniffer::startSniffer);
            myTopo.ToSniffer.connect(&mysniffer,&Sniffer::startSniffer);
        }
        void controlsend()
        {
            int ret;
            //void *startFunc1(void *a);
            //void *p = (void *)a;
        void * startFunc1(void * tmp);
        void * startFunc2(void * tmp);
            ret = pthread_create(&mythread,NULL,startFunc1,this);
            ret = pthread_create(&mythread,NULL,startFunc2,this);
            if(ret < 0)
                printf("thread create wrong!\n");
        }
};
        void * startFunc1(void * tmp)
        {
                Control * p = (Control *)tmp;
                    p ->myLoc.startLoc();
        }
        void * startFunc2(void * tmp)
        {
                Control * p = (Control *)tmp;
                p -> myTopo.startTopo();
        }
int main()
{

    int ret;
    Control mycontrol;
    mycontrol.controlsend();
    while(1);
    return 0;
}

Sniffer实现了 “槽” --- 即响应函数。

// 在这里指定信号，这里的信号是不带参数的，signaln表示带几个参数，后面将会用
        // 这个信号与指定的槽进行绑定的。

signal0<> ToSniffer;   

Sniffer mysniffer;
        Location myLoc;
        Topocation myTopo;
        Control()
        {
            myLoc.ToSniffer.connect(&mysniffer,&Sniffer::startSniffer);
            myTopo.ToSniffer.connect(&mysniffer,&Sniffer::startSniffer);
        }

在这里建立了链接。

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

信号和槽的概念解决了 低耦合和高内聚。使得模块间的耦合度降低。

可以用来实现 模块A 和B 调用公共模块。模块间省去了 用while循环的方式被动的接受命令，而是主动相应。