在具有多态特性的类体系中，向客户提供使用接口，而不去暴露类的体系结构。

class="baidu_pl">

class="article_content clearfix">

class="htmledit_views">

先举个例子，我们在开发中，经常会处理很多异步消息，比如：io消息、信号、定时器等，现在我们就建立一个消息处理器系统，代码如下：

class="tags" href="/tags/STRUCT.html" title=struct>struct msg
{
int msg_id;

    char data[1];
};
class BaseMsgProcessor
{
public:
    virtual int process_msg(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {
        std::cout << "process general msg/n";
        return 0;
    }
};

class IOMsg : public BaseMsgProcessor
{
public:
    virtual int process_msg(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {
        std::cout << "process io msg/n";
        return 0;
    }
};

class TimeOutMsg : public BaseMsgProcessor
{
public:
    virtual int process_msg(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {
        std::cout << "process TimeOutMsg msg/n";
        return 0;
    }
};

class SignalMsg : public BaseMsgProcessor
{
public:
    virtual int process_msg(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {
        std::cout << "process SignalMsg msg/n";
        return 0;
    }
};

上面的类结构，相当于像用户暴露了process_msg接口，用户会做如下的使用方法

BaseMsgProcessor * processor = NULL;

//io消息
class="tags" href="/tags/STRUCT.html" title=struct>struct msg m;

    m.msg_type = MT_IO;
    processor = new IOMsg;
    processor->process_msg(&m);
    delete processor;
    processor = NULL;

    //超时消息
    m.msg_type = MT_TIMEOUT;
    processor = new TimeOutMsg;
    processor->process_msg(&m);
    delete processor;
    processor = NULL;

    //处理信号
    m.msg_type = MT_SIGNAL;
    processor = new SignalMsg;
    processor->process_msg(&m);
    delete processor;
    processor = NULL;

这里的问题在哪里呢？

1、用户需要识别不同的消息处理器，有时这个识别逻辑可能比较复杂，所以容易出错。而原本这个消息处理器体系结构的组织、规划，是程序作者最清楚的。

2、需要负责处理器实例的创建、回收。有时，我们处理器的实例并不是通过简单的new/delete，创建、释放的，所以这个过程容易让用户产生使用上的错误。

如果“消息处理器”的作者，把整个使用过程都提供出来，就可以易用许多。如下：

enum msg_type
{
    MT_IO,
    MT_TIMEOUT,
    MT_SIGNAL
};

class="tags" href="/tags/STRUCT.html" title=struct>struct msg
{
    int msg_id;
    int msg_type;
    char data[1];
};
class BaseMsgProcessor
{
public:
    static int process(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {

BaseMsgProcessor * processor = Factory(msg->msg_type);

if (!processor)
return -1;

class="tags" href="/tags/STRUCT.html" title=struct>struct msg m;

int r = processor->process_msg(&m);

delete processor;
processor = NULL;

return r;
}

    static BaseMsgProcessor * Factory(int msg_type)
    {
        BaseMsgProcessor *process = NULL;
        switch(msg_type)
        {
        case MT_IO:
process = new IOMsg;
        case MT_SIGNAL:
            process = new SignalMsg;
        case MT_TIMEOUT:
            process = new TimeOutMsg;
        default:
            ;
        }

        return process;
    }
    private:
    virtual int process_msg(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {
        std::cout << "process general msg/n";
        return 0;
    }
};

class IOMsg : public BaseMsgProcessor
{
private:
    virtual int process_msg(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {
        std::cout << "process io msg/n";
        return 0;
    }
};

class TimeOutMsg : public BaseMsgProcessor
{
private:
    virtual int process_msg(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {
        std::cout << "process TimeOutMsg msg/n";
        return 0;
    }
};

class SignalMsg : public BaseMsgProcessor
{
private:
    virtual int process_msg(class="tags" href="/tags/STRUCT.html" title=struct>struct msg *msg)
    {
        std::cout << "process SignalMsg msg/n";
        return 0;
    }
};

用户只需要调用一下process，不用关心 process内部的细节

class="tags" href="/tags/STRUCT.html" title=struct>struct msg m;

BaseMsgProcessor::process(&m);