C++ 设计模式 面向对象设计原则

C++ 设计模式 面向对象设计原则

软件设计的金科玉律：复用

面对对象设计最大额优势在于：抵御变化

 

因为"变化"的存在，为软件设计带来了复杂性，那么如何解决？

1. 分解：分而治之，大问题分解为小问题
2. 抽象：由于不能掌握全部的复杂对象，选择忽视它的非本质细节，而去处理泛化和理想化的对象模型。

下面以画图为目的（图形工具），进行分解和抽象两种解决方案的演示：

按照C++的编程规范，不同职责的类应该处于不同的文件中，而字段（成员变量）一般都是private类型，此处为了更方便的展示思想，会忽略部分编程规范。

分解版本：

class Point

class Point{
public:
    int x;
    int y;
};

class Line

class Line{
public:
    Point start;
    Point end;

    Line(const Point & start,const Point & end){
        this->start = start;
        this->end = end;
    }
};

class Rect

class Rect{
public:
    Point LeftUp;
    int width;
    int height;

    Rect(const Point & leftUp,int width,int height){
        this->LeftUp = leftUp;
        this->width = width;
        this->height = height;
    }
};

具体的业务部分（画图部分）

class MainFrom

class MianFrom : public Form{
private:
    Point p1;
    Point p2;

    vector<Line> lineVector;
    vector<Rect> rectVector;
public:
    MainForm(){
        //.........
    }
private:
    //具体的鼠标操作
    virtual void OnMouseDown(const MouseEventArgs & e);//鼠标摁下
    virtual void OnMouseUp(const MouseEventArgs & e);//鼠标抬起
    virtual void OnPaint(const MouseEventArgs & e);
};

具体实现：

void MainFrom::OnMouseDown(const MouseEventArgs & e){
    p1.x = e.X;
    p1.y = e.Y;
    //.......
    Form::OnMouseDown(e);
}
void MainFrom::OnMouseUp(const MouseEventArgs & e){
    p2.x = e.X;
    p2.y = e.Y;
    //.......
    if(rdoLine.Checked){
        //如果是划线，那么就把线放到vector中
        Line line(p1,p2);
        lineVector.push_back(line);
    }
    else if(rdoRect.Checked){
        //如果是矩形，那么就把各个点坐标放到vector中
        int width = abs(p2.x - p1.x);
        int height = abs(p2.y - p1.y);
        Rect rect(p1,width,height);
        rectVector.push_back(rect);
    }
    //....
    this->Refresh();
    Form::OnMouseDown(e);
}
void MainFrom::OnPaint(const MouseEventArgs & e){
    //针对直线
    for(int i = 0;i < lineVector.size();i++){
        e.Graphics.DrawLine(Pens.Red,
                            lineVector[i].start.x,
                            lineVector[i].start.y,
                            lineVector[i].end.x,
                            lineVector[i].end.x,);
    }

    //针对矩形
    for(int i = 0;i < lineVector.size();i++){
        e.Graphics.DrawRectangle(Pens.Red,
                            rectVector[i].LeftUp,
                            rectVector[i].width,
                            rectVector[i].height);
    }
    //.......
    Form::OnMouseDown(e);

}

可以看到，在MainFrom中，具体的绘图执行是在OnPaint中执行的，但是目前只是画质矩形和直线，如果形状很多的情况下，显然会出现责任冗余的情况

那么我们更换一种方式：利用抽象来解决这个问题：

抽象版本：

多做一个shape类（抽象类）

class shape{
public:
    shape();
    virtual void Draw(const Graphics& g) = 0;
    virtual ~shape(){}
};

所有的形状都继承于这个类  ，将划线和画矩形的具体执行过程都放置在相应的类中完成即可

class Point{
public:
    int x;
    int y;
};

class Line : public shape{
public:
    Point start;
    Point end;

    Line(const Point & start,const Point & end){
        this->start = start;
        this->end = end;
    }
    //各自形状负责话各自的形状
    virtual void Draw(const Graphics& g){
        g.Graphics.DrawLine(Pens.Red,
                            start.x,start.y,end.x,end.x,);
    }
};
class Rect : public shape{
public:
    Point LeftUp;
    int width;
    int height;

    Rect(const Point & leftUp,int width,int height){
        this->LeftUp = leftUp;
        this->width = width;
        this->height = height;
    }
    //各自形状负责话各自的形状
    virtual void Draw(const Graphics& g){
        g.Graphics.DrawRectangle(Pens.Red,
                            LeftUp,width,height);
    }
};

class MainFrom 区别于之前分解版本的Class MainFrom ，vector减少至一个，增加了析构函数中的内容

class MainFrom : public Form{
private:
    Point p1;
    Point p2;

    vector<shape *> shapeVector;//此处进行更改
public:
    MainForm(){
        //.........
    }
    ~MainFrom(){
        for(int i = 0;i<shapeVector.size();++i){
            delete shapeVector[i];
        }
    }
private:
    //具体的鼠标操作
    virtual void OnMouseDown(const MouseEventArgs & e);//鼠标摁下
    virtual void OnMouseUp(const MouseEventArgs & e);//鼠标抬起
    virtual void OnPaint(const MouseEventArgs & e);
};

 具体执行过程

void MainFrom::OnMouseDown(const MouseEventArgs & e){
    p1.x = e.X;
    p1.y = e.Y;
    //.......
    Form::OnMouseDown(e);
}
void MainFrom::OnMouseUp(const MouseEventArgs & e){
    p2.x = e.X;
    p2.y = e.Y;
    //.......
    if(rdoLine.Checked){
        //如果是划线，那么就把线放到vector中
        shapeVector.push_back(new Line(p1,p2));
    }
    else if(rdoRect.Checked){
        //如果是矩形，那么就把各个点坐标放到vector中
        int width = abs(p2.x - p1.x);
        int height = abs(p2.y - p1.y);
        shapeVector.push_back(new Rect(p1,width,height));//析构需要释放
    }
    //....
    this->Refresh();
    Form::OnMouseDown(e);
}
void MainFrom::OnPaint(const MouseEventArgs & e){
    for(int i = 0;i < shapeVector.size();i++){
        shapeVector[i]->Draw(e.Graphics);//多态调用，各司其职
    }
    //.......
    Form::OnMouseDown(e);
}

下面对比核心程序段：

如果单纯的看代码，显然差不多，但是从可扩展性的角度出发，现在不但要画矩形和直线，还要画圆，菱形等等

哪儿种方法的可扩展性更好呢？哪儿个代码的修改成本和测试成本更低呢？，高下立判。

这也是C++多态的核心部分，改变对象的行为。

如果增加需求，那么“抽象”情况下，我们中需要增加一个子类（父类为shape）即可，但是在分解的情况下，增加的可就不止一个地方了，修改的地方需要，开发和测试的成本也就越高。

 

根据上面的例子，我们可以重新认识一下面向对象：

1：理解隔离变化

从宏观层面来看，面向对象的构建方式更能适应软件的变化，能将变化所带来的影响减为最小。class shape就是最好的例子，充分地证明了抽象类能够隔离变化的功能

2：各司其职

从微观层面来看，面向对象的方式更强调各个类的“责任”

由于需求变化导致的新增类型不应该影响原来类型的实现——所谓各负其责

分解的责任是在OnPaint（MainFrom），而在抽象中，责任是在各个子类中进行实现的。

3：对象是什么

从语言实现层面来看，对象封装了代码和数据

从规格层面来看，对象是一系列可被使用的公共接口

从概念层面来看，对象是某种拥有责任的抽象

 

面向对象的设计原则：

1，依赖倒置原则（DIP）

高层模型（稳定）不应该依赖于底层模式（变化），二者都应该依赖于抽象（稳定）

抽象（稳定）不应该依赖于实现细节（变化），实现细节应该依赖于抽象（稳定）

例子中的shape就是抽象，隔离了变化（隔离了MainFrom和Line和Rect）

2，开放封闭原则（OCP）

对扩展开放，对更改封闭

类模块应该是可扩展的，但是不可修改

例子中，如果存在shape抽象类，那么扩展直接继承shape即可，不需要更改其他部分，反观分解情况，修改的部分很多

3，单一责任原则（SRP）

一个类应该仅有一个引起它变化的原因

4，LisKov替换原则（LSP）

子类必须能够替换他们的父类（IS-A）

继承表达类型抽象

5，接口隔离原则（ISP）

有必要在Public，接口小而完备

6，优先使用对象组合，而不是类继承

类继承为“白箱复用”，对象组合为“黑箱复用”

7，封装变化点

使用封装来创建对象之间的分界层，使设计者可以在分界的一侧进行修改而不是干涉另一侧，从而形成一种松耦合。

8，针对接口编程，而不是针对实现编程

只给客户接口，而不需要让客户知道具体的数据类型