读c++模型设计体会

读c++模型设计体会

    学习c++是去年开始的，不过真正算的上理解它还是从generic programming和这本书开始。这本书的内容比较上层，涉及到c++程序设计的精髓，是掌握基本语法之后进入实际设计程序的一个思想指导。我经过一年的练习，已经进入，设计程序的阶段了。

（一）c++的精髓

    c++区别于c在于它具有c所没有的扩展性，重用性，灵活性。具体的说c++允许程序员，将问题的具体实现的细节推迟到运行时，而不是c的编译时期。这样的好处是，我们可以在需要的时候，在那些未具体实现的地方扩充原有的功能，重复使用已有的代码，从而节约编写应用程序的时间。然而，要灵活掌握这个工具难度可想而知。下面进入正题。

（二）模型

c++最大的优势在于对问题的封装，设置于对一个动态事件也不例外。那么对于现实中的一个具体问题，如何去分割？有什么可以遵循的法则吗？答案自然是有。但是，妄想用一种万能的方法来完成千变万化的世界，实在是愚蠢之极。那么，我们就不学习方法了吗？非也。我么学习的目的是使用一种已经存在的方法推理出我们解决问题的一个具体，何时的方法。

1）对象和方法

任何一个问题的都是由它内部的各种因素决定，我们抓住这些因素加以总结并转换成c++中的各种class，以class为桥梁，实现一个完整的问题解决方案。

总体而言，我们把问题分成静态的因素和动态的因素。静态就是说因素本身存在的意义是表现；而动态表示为了描述或者操纵某个静态的因素。对于程序的世界，静态因素对应数据，动态因素对应方法（functions）。合理的划分数据和并为数据提供一种安全高效的方法，则是编程人员的最终使命。

Abstract factory模型

    这个模型我在学习ModernC++DesignGenericProgrammingandDesignPatternsApplied的时候已经学习过，这里总结一下对这个模型的一些想法。显然这是一个典型的泛型编程的一个方法。它将各种“产品”的生产方法抽象成为一个接口，所有的客户在需要产品的时候，只需要通过这个接口就可以完成产品的生产。与直接的方法相比较，这样做避免了客户自己动手create产品（复杂的产品生产细节，被factory隐藏掉了），在用户看来这真的是一个很好的事情；而对于产品生产者而言也有了一个统一的接口来管理自己。主要的实现原理如下：
class abstractFactory{
public:
    abstractFactory();
    vitual ~abstractFactory(){};
    virtual createProduct0(){}//I don't use pure virtual function here to avoid overwiriting all the functions
    virual createProdunct1(){}
    .
    .
    .
private:
    abstractFactory* p_abs_factory_;
};
class product0Factory:public abstractFactory{
public:
    product0Factory();
    ~product0Factory();
    product0* createProduct0(void){ p_abs_factory_ = this; return new produnct0; }

};
class product1Factory:public abstractFactory
.
.
.

class product0{
public:
};
使用方法：
if(product0){
    product0Factory product0_fac;
    product0* p_product0 = product0_fac.createProduct0();
}
if(product1){
.
.
.
}
    在basic class里面给出了生产各种产品的接口，但在sub class 里面重写这些接口完成具体对象的创建工作。
这个方法有一个缺点：对于多个产品存在多个平行的sub factory class，似乎存在一些重复性的事情，与c++程序设计中避免类膨胀矛盾，后面我会介绍一个新的设计模式解决这个问题。

build模式

class cEye{
public:
        cEye(){ DEBUG("I am cEye!\n"); }
};
class cNose{
public:
        cNose(){ DEBUG("I am cNose!\n"); }
};
class cEar{
public:
        cEar(){ DEBUG("I am cEar!\n"); }
};
class cMouth{
public:
        cMouth(){ DEBUG("I am cMouth!\n"); }
};
class cFace_builder{
public:
        cFace_builder(){ DEBUG("In cFace_builder!\n"); }
        virtual cEye* build_eye(){}
        virtual cNose* build_nose(){}
        virtual cEar* build_ear(){}
        virtual cMouth* build_mouth(){}
//      virtual face* get_result(void){ return NULL; }
        virtual ~cFace_builder(){}
private:
        cFace_builder(cFace_builder& fb){}
};
class cFace{
public:
//      cFace():face_builder(NEW cFace_builder){}
        void create_face(cFace_builder& face_builder){
                eye_ = face_builder.build_eye();
                nose_ = face_builder.build_nose();
                ear_ = face_builder.build_ear();
                mouth_ = face_builder.build_mouth();
                //return this;
        }
private:
        cEye* eye_;
        cNose* nose_;

        cEye* eye_;
        cNose* nose_;
        cEar* ear_;
        cMouth* mouth_;
//      cFace_builder* face_builder;
};


class cEye_builder:public cFace_builder{
public:
        virtual cEye* build_eye(void){ DEBUG("In cEye_builder\n"); return NEW cEye; }
        cNose* build_nose(){ return NEW cNose; }
        cEar* build_ear(){ return NEW cEar; }
        cMouth* build_mouth(){ return NEW cMouth; }
};
class cNose_builder:public cFace_builder{
public:
        virtual cNose* build_nose(void){ DEBUG("In cNose_builder\n"); return NEW cNose; }
        cEar* build_ear(){ return NEW cEar; }
        cEye* build_eye(void){ return NEW cEye; }
        cMouth* build_mouth(){ return NEW cMouth; }
};
class cEar_builer:public cFace_builder{
public:
        virtual cEar* build_ear(void){ DEBUG("In cEar_builder\n"); return NEW cEar; }
        cEye* build_eye(void){ return NEW cEye; }
        cNose* build_nose(){ return NEW cNose; }
        cMouth* build_mouth(){ return NEW cMouth; }
};
class cMouth_builder:public cFace_builder{
public:
        virtual cMouth* build_mouth(void){ DEBUG("In cMouth_builder\n"); return NEW cMouth; }
        cEar* build_ear(){ return NEW cEar; }
        cEye* build_eye(void){ return NEW cEye; }
        cNose* build_nose(){ return NEW cNose; }
};

int
main()
{
cFace face;

cMouth_builder mouth_builder;
face.create_face(mouth_builder);

}

行为模型系列

除了结构模型用于搭建程序的结构框架用于维护数据等等之外，我们在很多的时候还需要对一系列的行为进行描述；在指定的条件下，可以完成指定的动作。C++本身是一种灵活的语言，因此，自然会有这个方面的支持。下面我就介绍行为模型。

a.Chain 模型

chain 模型可以完成对一个不确定的request的灵活处理，实现的实例如下：
#include


#include "macros.h"
using namespace std;
/*
 *      chain pattern is used for passing the request to the
 *      object who can deal with it
 *
 */
class cHelpHandler{
public:
        cHelpHandler():help_(NULL){}
        cHelpHandler(cHelpHandler* p):help_(p){}
        virtual bool set_handler(cHelpHandler* p);
        virtual bool handle_help(void);

private:
        cHelpHandler* help_;
};
bool cHelpHandler::set_handler(cHelpHandler* p)
{
        if(p != NULL){
                help_ = p;
                return true;
        }else
        return false;
}
bool cHelpHandler::handle_help(void)
{
        if(help_ != NULL)
                return help_->handle_help();
}
class cWindow:public cHelpHandler{
public:
        cWindow():cHelpHandler(){}
        cWindow(cWindow* p):cHelpHandler(p){}
private:
};

class cButton:public cHelpHandler{
public:
        cButton():cHelpHandler(){}
        cButton(cButton* p):cHelpHandler(p){}
};

以上实例代码比较简单，Button Window 需要处理某些help的请求，但是当一个请求来的时候究竟谁来处理它呢？是button还是window？不是很确定。但是我们可以按照上面的做法，在button和window里面从cHhelpHandle继承一些处理请求的接口，让后重新实现它们（主要是看请求是不是自己的，如果是的话就处理不是的话就传递给下一个对象），这样就可以实现一个动态的chain从而满足一种灵活的处理request的方法