设计模式(1)——简单工厂模式和策略模式的结合应用

一、前言

　　设计，为蓝图，为构建之根本。个人对于设计模式的理解：设计模式是软件开发过程中一些常用pattern的概括总结。这些思想终究是别人实践过程中存在着背景因素的产物，可以用，但不可滥用。

　　最近在学习软件设计模式方面的知识，在这里实现每个使用场景记录一下自己的学习过程。

二、功能

　　简单工厂模式：是属于工厂模式的一种，它使用一个集中了所有实例（产品）的创建逻辑的工厂类去实例化对象。外界只需要告诉工厂所需生产产品的类型，而无需关注生产的过程。将“类实例化的操作”与“使用对象的操作”分开，让使用者不用知道具体参数就可以实例化出所需要的“产品”类，从而避免了在客户端代码中显式指定，降低类之间的耦合。

　　策略模式：策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合，其实就是用来封装变化。GOF里关于策略模式的功能描述——“策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能”    “当不同的行为堆砌在同一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句”。

三、实例

　　以计算二维坐标空间两点间的不同类型距离（欧氏距离、曼哈顿距离和棋盘格距离）为例。

　　在基类定义一个抽象接口Calculate，在派生类中实现它。

// 距离计算基类
class DistanceBase
{
public:
    virtual ~DistanceBase() = default;
public:
    virtual double Calculate(cv::Point2d point1_, cv::Point2d point2_) = 0;
};

// 欧几里得距离计算类
class EuclideanDistance : public DistanceBase
{
public:
    double Calculate(cv::Point2d point1_, cv::Point2d point2_)
    {
        double result = 0.0;
        result = pow((point1_.x - point2_.x), 2) + pow((point1_.y - point2_.y), 2);
        result = sqrt(result);

        return result;
    }
};

// 曼哈顿距离计算类
class ManhattanDistance : public DistanceBase
{
public:
    double Calculate(cv::Point2d point1_, cv::Point2d point2_)
    {
        double result = 0.0;
        result = abs(point1_.x - point2_.x) + abs(point1_.y - point2_.y);

        return result;
    }
};

// 棋盘格距离计算类
class ChessboardDistance : public DistanceBase
{
public:
    double Calculate(cv::Point2d point1_, cv::Point2d point2_)
    {
        double result = 0.0;
        result = std::max(abs(point1_.x - point2_.x), abs(point1_.y - point2_.y));

        return result;
    }
};

　　工厂类的实现

enum DistanceType
{
    EUCLIDEAN = 0,
    MANHATTAN = 1,
    CHESSBOARD = 2,
};


class DistanceFactory
{
public:
    static DistanceBase* creatCalculator(DistanceType type)
    {
        DistanceBase* p = NULL;
        switch (type)
        {
        case DistanceType::EUCLIDEAN:
            p = new EuclideanDistance();
            break;
        case DistanceType::MANHATTAN:
            p = new ManhattanDistance();
            break;
        case DistanceType::CHESSBOARD:
            p = new ChessboardDistance();
            break;
        default:
            break;
        }

        return p;
    }
};

　　Client端代码，根据输入的DistanceType来控制工厂类具体实例化哪个距离计算对象

    DistanceBase* calculator = DistanceFactory::creatCalculator(DistanceType::EUCLIDEAN);
    double result = calculator->Calculate(cv::Point2d(1, 1), cv::Point2d(4, 5));

　　

　　简单工厂模式的缺点除了违背了开放封闭原则以外，通过以上的Client端代码可以发现，Client需要认识DistanceBase基类和DistanceFactory工厂类两个类，可不可以让其只认识一个类？

　　这个时候可以结合策略模式来实现all in one的目的，使计算算法彻底地与客户端分离。代码如下

class DistanceCalculator
{
public:
    DistanceCalculator(DistanceType type)
    {
        distance_ = NULL;

        switch (type)
        {
        case DistanceType::EUCLIDEAN:
            distance_ = new EuclideanDistance();
            break;
        case DistanceType::MANHATTAN:
            distance_ = new ManhattanDistance();
            break;
        case DistanceType::CHESSBOARD:
            distance_ = new ChessboardDistance();
            break;
        default:
            break;
        }
    }
    
    double Calculate(cv::Point2d point1_, cv::Point2d point2_)
    {
        if (distance_)
            return distance_->Calculate(point1_, point2_);
    }

private:
    DistanceBase* distance_;
};

　　Client端调用

    DistanceCalculator* calculator = new DistanceCalculator(DistanceType::EUCLIDEAN);
    double result = calculator->Calculate(cv::Point2d(1, 1), cv::Point2d(4, 5));

　　DistanceBase类为一个抽象策略，而EuclideanDistance、ManhattanDistance和ChessboardDistance类为三个具体策略，将实例化具体策略的的过程转移到DistanceCalculator类中，客户端只需实例DistanceCalculator一个类，使得具体的计算算法与客户端彻底分离。

　　鄙人才疏学浅，如有错误还请指出。