<总结> 设计模式之 开放封闭原则OCP C++示例

原文是C++ VIEW第二期的一篇译文，这里做个总结，便于查阅。

开放封闭原则

系统在添加新的需求的时候能够尽可能做到，只是添加新的代码 open for extension，而不需要修改原有模块代码 closed for modification

 

通过提取基类的方法，client 调用server 抽象基类abstract server的抽象接口，从而更换不同sever的时候，client的调用server的代码都不需要改动，接口不变，

只是server内容变化。

 

例子，

一个绘制函数，要求能够针对输入的不同对象，调用不同的绘制函数，如能够绘制矩形，圆形，适当调用矩形绘制函数，圆形绘制函数。

1.用c语言实现

这个例子其实给出了，c语言模拟c++类继承的方法。利用指针的强制转换,因为指针仅仅是地址可以指向任何对象，利用指针强制转换，告诉编译器具体按什么对象处理指针所指。

Listing 1
/*Procedural Solution to the Square/Circle Problem*/

enum ShapeType {circle, square};
struct Shape
{
    ShapeType itsType;
};
struct Circle
{
    ShapeType itsType;
    double itsRadius;
    Point itsCenter;
};
struct Square
{
    ShapeType itsType;
    double itsSide;
    Point itsTopLeft;
};
//
// 下面两个函数的实现定义在别处
//
void DrawSquare(struct Square*)
void DrawCircle(struct Circle*);
typedef struct Shape *ShapePointer;
void DrawAllShapes(ShapePointer list[], int n)
{
    int i;
    for (i=0; i<n; i++)
   {
        struct Shape* s = list[i];
        switch (s->itsType)
        {
          case square:
              DrawSquare((struct Square*)s);
              break;
         case circle:
             DrawCircle((struct Circle*)s);
             break;
        }
     }
}

 

上面的代码不符合open close法则，因为新加入其它的shape如椭圆， DrawAllShapes函数就需要变化。

2. C++的实现

Listing 2
/*OOD solution to Square/Circle problem.*/
class Shape
{
    public:
        virtual void Draw() const = 0;
};
class Square : public Shape
{
    public:
        virtual void Draw() const;
};
class Circle : public Shape
{
    public:
        virtual void Draw() const;
};
void DrawAllShapes(Set<Shape*>& list)
{
    for (Iterator<Shape*>i(list); i; i++)
        (*i)->Draw();
}

 

和上面C语言实现代码对比，显然符合open close 法则，加入新的shape， DrawAllShapes函数可保持不变，只是添加新的shape内容。

 

但是事实上如果有新的需求变化，DrawAllShapes也无法做到完全不变，任何模块只能是相对封闭，无法完全封闭。

例如我们有新的需求，要求绘制图形列表的时候，一种形状的图形要在另一种图形前面绘制。

解决方法，加入 顺序抽象类

Listing 3
/*Shape with ordering methods.*/
class Shape
{
    public:
        virtual void Draw() const = 0;

        virtual bool Precedes(const Shape&) const = 0;
        bool operator<(const Shape& s) {return Precedes(s);}
};

 

Listing 4
/*DrawAllShapes with Ordering*/
void DrawAllShapes(Set<Shape*>& list)
{
// copy elements into OrderedSet and then sort.
    OrderedSet<Shape*> orderedList = list;
    orderedList.Sort();
    for (Iterator<Shape*> i(orderedList); i; i++)
        (*i)->Draw();
}

Listing 5
/*Ordering a Circle*/
bool Circle::Precedes(const Shape& s) const
{
    if (dynamic_cast<Square*>(s))
        return true;
    else
        return false;
}

 

这里使用的Precedes函数，如果新加入shape需要改变，怎么样才能做到更好呢？

使用数据驱动获得封闭性，利用预先写好的table，我们将各个图形的优先顺序写入table，那么新加入shape只需要更新table加入新的shape。

Listing 6
/*Table driven type ordering mechanism*/
#include <typeinfo.h>
#include <string.h>
enum {false, true};
typedef int bool;
class Shape
{
public:
    virtual void Draw() const = 0;
    virtual bool Precedes(const Shape&) const;
    bool operator<(const Shape& s) const
        {return Precedes(s);}
private:
    static char* typeOrderTable[];
};

 

/*
译者注：由于typeinfo.name没有标准，因此最好直接用typeinfo作为表中的元素类型，而不是用类名字符串。
*/
char* Shape::typeOrderTable[] =
{
    “Circle”,
    “Square”,
    0
};
// This function searches a table for the class names.
// The table defines the order in which the
// shapes are to be drawn. Shapes that are not
// found always precede shapes that are found.
//
bool Shape::Precedes(const Shape& s) const
{

    const char* thisType = typeid(*this).name();
    const char* argType = typeid(s).name();
    bool done = false;
    int thisOrd = -1;
    int argOrd = -1;
    for (int i=0; !done; i++)
    {
        const char* tableEntry = typeOrderTable[i];
        if (tableEntry != 0)
        {
            if (strcmp(tableEntry, thisType) == 0)
                thisOrd = i;
            if (strcmp(tableEntry, argType) == 0)
                argOrd = i;
            if ((argOrd > 0) && (thisOrd > 0))
                done = true;
        }
        else // table entry == 0
            done = true;
    }
    return thisOrd < argOrd;
}

 

进一步扩展封闭性
故事还没有结束。我们已经设法使得Shape类层次和DrawShapes函数对于依赖于图形类型的画出顺序是封闭的。然而，如果画出顺序与图形类型无关，那么Shape派生类并不对这种顺序的变化封闭。我们似乎需要根据一个更加高层次的结构来决定画出各个shape的顺序。关于这个问题的深入彻底探讨已经超过了本文的范围；然而有兴趣的读者可能会考虑定义一个OrderedObject的抽象类，并从Shape类和OrderedObject类派生一个新的抽象类OrderedShape。

 

所有成员变量都应该是私有的

永远不要用全局变量

然而，有些情况下全局变量的方便性是很重要的。全局变量cout和cin就是例子。在这种情况下，如果没有破环开放―封闭（open-closed）原则，那么牺牲风格来获得这种方便性是值得的

RTTI是危险的

根据一般的经验，如果使用RTTI不会破坏开放―封闭（open-closed）原则，那么就是安全的