设计模式——工厂模式 （C++实现）

设计模式——工厂模式 （C++实现）

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。

 

工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。下面一个个介绍，首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，举个例子就明白了。有一家生产处理器核心的厂家，它只有一个工厂，能够生产两种核心的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

 

 

#include "stdafx.h"
#include <iostream>
using namespace std;

enum CpuCoreType{COREA,COREB};

//Cpu核心类
class CpuCore
{
public:
    virtual void Show() = 0;
};
//Cpu核心A类
class CpuCoreA:public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore A " << endl;
    }
};
//Cpu核心B类
class CpuCoreB : public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore B" << endl;
    }
};
//唯一的工厂，可以生产两种型号的处理器核，在内部判断
class Factory
{
public:
    CpuCore* CreateCpuCore(enum CpuCoreType type )
    {
        if(type == COREA)
            return new CpuCoreA();
        else if(type == COREB)
            return new CpuCoreB();
        else
            return NULL;
    };
};
class Test
{
public:
    CpuCore* pCpuCore;
    Factory factory;
public:
    void TestFactory()
    {
        pCpuCore = factory.CreateCpuCore(COREA);
        pCpuCore->Show();
        pCpuCore = factory.CreateCpuCore(COREB);
        pCpuCore->Show();
    }    
};
int _tmain(int argc, _TCHAR* argv[])
{
    Test test;
    test.TestFactory();
    cin.get();
    return 0;
}

 

这样设计的主要缺点之前也提到过，就是要增加新的核心类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

 

听起来很抽象，还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。

 

#include "stdafx.h"
#include <iostream>
using namespace std;

enum CpuCoreType{COREA,COREB};

//Cpu核心类
class CpuCore
{
public:
    virtual void Show() = 0;
};
//Cpu核心A类
class CpuCoreA:public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore A " << endl;
    }
};
//Cpu核心B类
class CpuCoreB : public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore B" << endl;
    }
};
//抽象工厂方法
class Factory
{
public:
    virtual    CpuCore* CreateCpuCore() = 0;
};
//生产A核心的工厂
class FactoryA : public Factory
{
public:
    CpuCoreA* CreateCpuCore()
    {
        return new CpuCoreA();
    }
};
//生产B核心的工厂
class FactoryB : public Factory
{
public:
    CpuCoreB* CreateCpuCore()
    {
        return new CpuCoreB();
    }
};
class Test
{
public:
    CpuCore* pCpuCore;
    FactoryA factoryA;
    FactoryB factoryB;
public:
    void TestFactory()
    {
        CpuCoreA* pCoreA = factoryA.CreateCpuCore();
        CpuCoreB* pCoreB = factoryB.CreateCpuCore();
        pCoreA->Show();
        pCoreB->Show();
    }    
};
int _tmain(int argc, _TCHAR* argv[])
{
    Test test;
    test.TestFactory();
    cin.get();
    return 0;
}

 

 

 工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。   

 

　　既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器（假设上面两种模式都是生产的单核），现在也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。          

 

#include "stdafx.h"
#include <iostream>
using namespace std;

enum CpuCoreType{COREA,COREB};

//单核Cpu核心类
class CpuCore
{
public:
    virtual void Show() = 0;
};
//Cpu核心A类
class CpuCoreA:public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore A " << endl;
    }
};
//Cpu核心B类
class CpuCoreB : public CpuCore
{
public:
    void Show()
    {
        cout <<"CpuCore B" << endl;
    }
};
//多核Cpu核心类
class MultiCpuCore
{
public:
    virtual void Show() = 0;
};
//多核Cpu核心A类
class MultiCpuCoreA : public MultiCpuCore
{
public:
    void Show()
    {
        cout <<"Multi CpuCore A" << endl;
    }
};
//多核Cpu核心B类
class MultiCpuCoreB : public MultiCpuCore
{
public:
    void Show()
    {
        cout <<"Multi CpuCore B" << endl;
    }
};
//工厂，抽象工厂方法
class Factory
{
public:
    virtual    CpuCore* CreateCpuCore() = 0;
    virtual MultiCpuCore* CreateMultiCpuCore() = 0;
};
//工厂A，专门用来生产A类型的处理器
class FactoryA : public Factory
{
public:
    CpuCore* CreateCpuCore()
    {
        return new CpuCoreA();
    }
    MultiCpuCore* CreateMultiCpuCore()
    {
        return new MultiCpuCoreA();
    }
};
//工厂B，专门用来生产B类型的处理器
class FactoryB : public Factory
{
public:
    CpuCore* CreateCpuCore()
    {
        return new CpuCoreB();
    }
    MultiCpuCore* CreateMultiCpuCore()
    {
        return new MultiCpuCoreB();
    }
};
class Test
{
public:
    CpuCore* pCpuCore;
    FactoryA factoryA;
    FactoryB factoryB;
public:
    void TestFactory()
    {
        CpuCore* pCoreA = factoryA.CreateCpuCore();
        MultiCpuCore* pMultiCoreA = factoryA.CreateMultiCpuCore();
        CpuCore* pCoreB = factoryB.CreateCpuCore();
        MultiCpuCore* pMultiCoreB = factoryB.CreateMultiCpuCore();
        pCoreA->Show();
        pCoreB->Show();
        pMultiCoreA->Show();
        pMultiCoreB->Show();
    }    
};
int _tmain(int argc, _TCHAR* argv[])
{
    Test test;
    test.TestFactory();
    cin.get();
    return 0;
}

 

 

 

 

 

喝咖啡写脚本,顺便再加一点点CSS语法糖 2.五分钟学会Less

    CoffeeScript + Html5 + Less这个新组合,看上去Less更容易拿下,先尝尝糖吧.

    Less这么小个东西,竟然要翻墙,真是没有天理,简直不可理喻,先不管那么多了,那就看这个吧.http://www.lesscss.net/

    这个Less,比起CSS,就是要更少的代码,更多的动态,更多的重用.提供了变量,继承,运算,函数等,我们就来看看吧.

    首先是这玩意最后怎么生成CSS, 两种用法,我们先用一秒钟选择最容易的,就是网站提供的生成CSS功能.学了就可以使用了.然后当然也可以在RunJS里直接写.环境问题解决了,来看看语法吧.

    1.变量: 这功能好啊,为什么CSS当年定标准的时候没有想到呢?

其实就是定义一个常量  @car : 值;   使用的时候 @var  这个很象Sql的变量定义.

    2.混合: 这功能好啊,为什么CSS当年定标准的时候没有想到呢?

其实就是在CSS里再引入另一CSS的名称,如下:

@fontColor: red;

.h2 {
    font-size: 22px;
}

div {
  color:@fontColor;
    .h2
}

真是简单啊.任何 CSS class, id 或者 元素 属性集都可以以同样的方式引入。

    3.带混合的参数: 就是混合的定义里可以加参数 .h2(@变量名[: 默认值]),还可以用...表示多个参数.如下:

.h2(@size: 12px) {
    font-size: @size;
}

div {
  color:@fontColor;
    .h2(22px)
}

   

   Pattern-matching and Guard expressions 比较多,就是条件判断后再混合.先略过

   4.嵌套: 这功能好啊,为什么CSS当年定标准的时候没有想到呢?

就是CSS里再定义CSS,如下:

#header        { color: black;
    .navigation  { font-size: 12px }
    .logo        { width: 300px;
    &:hover    { text-decoration: none }
    }
    }

&这个符号还有更多的用法,先略过.

   5.运算: 这功能好啊,为什么CSS当年定标准的时候没有想到呢?

任何数字、颜色或者变量都可以参与运算,如border: (@width * 2) solid black;

   6.函数: LESS 提供了多种函数用于控制颜色变化、处理字符串、算术运算等等。

   7.名字空间: 为了更好的组织的封装, 引入的时候用 > 号. 空间名称 > 样式名称,如:

#header a {
    color: orange;
    #bundle > .button;
    }

   8.作用域: 如变量定义等,类似JS

   9.注释: 除了/**/注释, 也可以用//注释,但生成后自动过滤掉,很奇怪的是当初定义CSS时,为什么不支持//这样的注释呢?

   10.导入: Importing如:

@import "lib.less";
    @import "lib";
@import "lib.css";

   11.字符串插值: 可以把变量插到字符串里.@{val},如:background-image: url("@{base-url}/images/bg.png");

   12.避免编译: ~"XXX", 这样XXX内容将原样输出成CSS

   13.选择插值: @{val}这样的变量还可以用地选择器名称上,如: .@{name} {color:black;}

   14.JavaScript evaluation: 反向使用JS, 作者不建议使用.

然后呢?然后就没有了.Less就是这么少,除掉不建议使用的第14条,及略过的复杂部分,总共就十几条规则,大约5分钟就可以学完了,当然我边学边写花的时间比5分钟要多,还有更多的就是Less里的函数了,不过以直觉来看,这些函数用不用都成,大多都是和颜色相关的.

 

分类: C/C++, 设计模式

标签: C++, 工厂模式, 设计模式, 单例模式