设计模式之抽象工厂模式

抽象的产品类A

#pragma once
class AbstractProductA
{
public:
    virtual ~AbstractProductA();

protected:
    AbstractProductA();
};

#include "AbstractProductA.h"


AbstractProductA::AbstractProductA()
{
}


AbstractProductA::~AbstractProductA()
{
}

 

抽象的产品类B

#pragma once
class AbstractProductB
{
public:
    virtual ~AbstractProductB();

protected:
    AbstractProductB();
};

#include "AbstractProductB.h"


AbstractProductB::AbstractProductB()
{
}


AbstractProductB::~AbstractProductB()
{
}

 

派生产品类A1

#pragma once
#include "AbstractProductA.h"
class ProductA1 :
    public AbstractProductA
{
public:
    ProductA1();
    ~ProductA1();
};

#include "ProductA1.h"
#include <iostream>


ProductA1::ProductA1()
{
    std::cout << "ProductA1..." << std::endl;
}


ProductA1::~ProductA1()
{
}

 

派生产品类A2

#pragma once
#include "AbstractProductA.h"
class ProductA2 :
    public AbstractProductA
{
public:
    ProductA2();
    ~ProductA2();
};

#include "ProductA2.h"
#include <iostream>


ProductA2::ProductA2()
{
    std::cout << "ProductA2..." << std::endl;
}


ProductA2::~ProductA2()
{
}

 

派生产品类B1

#pragma once
#include "AbstractProductB.h"
class ProductB1 :
    public AbstractProductB
{
public:
    ProductB1();
    ~ProductB1();
};

#include "ProductB1.h"
#include <iostream>


ProductB1::ProductB1()
{
    std::cout << "ProductB1..." << std::endl;
}


ProductB1::~ProductB1()
{
}

 

派生产品类B2

#pragma once
#include "AbstractProductB.h"
class ProductB2 :
    public AbstractProductB
{
public:
    ProductB2();
    ~ProductB2();
};

#include "ProductB2.h"
#include <iostream>


ProductB2::ProductB2()
{
    std::cout << "ProductB2..." << std::endl;
}


ProductB2::~ProductB2()
{
}

 

派生工厂类1

#pragma once
#include "AbstractFactory.h"
#include "ProductA1.h"
#include "ProductB1.h"

class ConcreateFactory1 :
    public AbstractFactory
{
public:
    ConcreateFactory1();
    ~ConcreateFactory1();

    AbstractProductA *CreateProductA();

    AbstractProductB *CreateProductB();
};

#include "ConcreateFactory1.h"


ConcreateFactory1::ConcreateFactory1()
{
}


ConcreateFactory1::~ConcreateFactory1()
{
}

AbstractProductA * ConcreateFactory1::CreateProductA()
{
    return new ProductA1();
}

AbstractProductB * ConcreateFactory1::CreateProductB()
{
    return new ProductB1();
}

 

派生工厂类2

#pragma once
#include "AbstractFactory.h"
#include "ProductA2.h"
#include "ProductB2.h"

class ConcreateFactory2 :
    public AbstractFactory
{
public:
    ConcreateFactory2();
    ~ConcreateFactory2();

    AbstractProductA *CreateProductA();

    AbstractProductB *CreateProductB();
};

#include "ConcreateFactory2.h"


ConcreateFactory2::ConcreateFactory2()
{
}


ConcreateFactory2::~ConcreateFactory2()
{
}

AbstractProductA * ConcreateFactory2::CreateProductA()
{
    return new ProductA2();
}

AbstractProductB * ConcreateFactory2::CreateProductB()
{
    return new ProductB2();
}

 

抽象工厂类基类

#pragma once
#include "AbstractProductA.h"
#include "AbstractProductB.h"

class AbstractFactory
{
public:
    virtual ~AbstractFactory();

    virtual AbstractProductA *CreateProductA() = 0;

    virtual AbstractProductB *CreateProductB() = 0;

protected:
    AbstractFactory();
};

#include "AbstractFactory.h"


AbstractFactory::AbstractFactory()
{
}


AbstractFactory::~AbstractFactory()
{
}

 

测试

#include <iostream>
#include "AbstractFactory.h"
#include "ConcreateFactory1.h"
#include "ConcreateFactory2.h"

int main()
{
    AbstractFactory *fac1 = new ConcreateFactory1();
    fac1->CreateProductA();
    fac1->CreateProductB();

    AbstractFactory *fac2 = new ConcreateFactory2();
    fac2->CreateProductA();
    fac2->CreateProductB();

　　//内存释放

    if (imp)
    {
        delete imp;
        imp = NULL;
    }

    if (abs)
    {
        delete abs;
        abs = NULL;
    }

    std::cout << "Hello World!\n"; 
}