011 --- 第15章 抽象工厂模式

简述：

　　抽象工厂模式：提供一个创建一系列相关或相互依赖的对象的接口，而无需指定它们具体的类。

　　抽象工厂模式包括：抽象工厂类、具体工厂类、抽象产品类、具体产品类

　　　　抽象工厂类，它里面应该包含所有的产品创建的抽象方法。

　　　　具体工厂类：创建具有特定实现的产品对象。

　　　　抽象产品类：它们都有可能有几种不同的实现。

　　　　具体产品类：对抽象产品的具体分类的实现。

注：抽象工厂模式C#可以用反射的技术来实现，但是C++没有这种已经封装好的技术，所以我自己利用MFC的动态创建对象技术来模拟了反射技术实现的抽象工厂模式。

例：调用不同的数据库

代码如下：

CDynamicCreateObject.h(动态创建对象头文件)：

#pragma once

#ifndef _DYNAMICCREATEOBJECT_H_
#define _DYNAMICCREATEOBJECT_H_

#include <iostream>
using namespace std;

#define DECLARE_DYNAMICCREATEOBJECT() 
    static CRunTime RunTime; 
    static CDynamicCreateObject* CreateObject();

#define IMPLEMENT_DYNAMICCREATEOBJECT(ThisClass) 
    CDynamicCreateObject* ThisClass::CreateObject() 
    { 
            return new ThisClass; 
    } 
    CRunTime ThisClass::RunTime = { #ThisClass, &ThisClass::CreateObject, NULL }; 
    CInitObjectList InitObjectList##ThisClass(&ThisClass::RunTime);
    

class CDynamicCreateObject
{
public:
    static CDynamicCreateObject* MateStringThenCreateObject(string szClassName);
};

class CRunTime
{
public:
    string m_szClassName;
    CDynamicCreateObject* (*pFunCreateObject)();
    CRunTime* pNext;
    static CRunTime* pTop;
};

class CInitObjectList
{
public:
    CInitObjectList(CRunTime* pRunTime)
    {
        pRunTime->pNext = CRunTime::pTop;
        CRunTime::pTop = pRunTime;
    }
};

#endif   //_DYNAMICCREATEOBJECT_H_

CDynamicCreateObject.cpp(动态创建对象源文件)：

#include "CDynamicCreateObject.h"

CRunTime* CRunTime::pTop = NULL;

CDynamicCreateObject* CDynamicCreateObject::MateStringThenCreateObject(string szClassName)
{
    CRunTime* pRunTime = CRunTime::pTop;
    while (pRunTime)
    {
        if (pRunTime->m_szClassName ==  szClassName)
        {
            if (pRunTime->pFunCreateObject == NULL)
                return NULL;
            else
                return (*(pRunTime->pFunCreateObject))();
        }
        pRunTime = pRunTime->pNext;
    }
    return NULL;
}

抽象工厂模式代码：

#include <iostream>
#include <string>
// 增加动态创建对象功能，这是由于C++没有C#中的反射技术，但可以自己模拟MFC中的动态创建对象技术实现
#include "CDynamicCreateObject.h"
using namespace std;

// 用户表类
class CUser
{
private:
    int m_nID;
    string m_szName;

public:
    CUser() : m_nID(0), m_szName("") {};

    int GetID() { return m_nID; }
    void SetID(int nID) { m_nID = nID; }

    string GetName(){ return m_szName; }
    void SetName(string szName){ m_szName = szName; }
};

// 部门表类
class CDepartment{};

// IUser(抽象产品类)
class CDatabaseUser :
    public CDynamicCreateObject
{
public:
    virtual void Insert(CUser* pUser) = 0;
    virtual CUser* GetUser(int nID) = 0;
};

// SQLServerUser(具体产品类)
class CSQLServerUser : public CDatabaseUser
{
// 抽象工厂模式动态创建
public:
    DECLARE_DYNAMICCREATEOBJECT()
// 抽象工厂模式动态创建
public:
    void Insert(CUser* pUser)
    {
        cout << "在SQL Server中给User表增加一条记录。" << endl;
    }

    CUser* GetUser(int nID)
    {
        cout << "在SQL Server中根据ID得到User表一条记录。" << endl;
        return NULL;
    }
};
// 抽象工厂模式动态创建
IMPLEMENT_DYNAMICCREATEOBJECT(CSQLServerUser)
// 抽象工厂模式动态创建

// AccessUser(具体产品类)
class CAccessUser : public CDatabaseUser
{
// 抽象工厂模式动态创建
public:
    DECLARE_DYNAMICCREATEOBJECT()
// 抽象工厂模式动态创建
public:
    void Insert(CUser* pUser)
    {
        cout << "在Access中给User表增加一条记录。" << endl;
    }

    CUser* GetUser(int nID)
    {
        cout << "在Access中根据ID得到User表一条记录。" << endl;
        return NULL;
    }
};
// 抽象工厂模式动态创建
IMPLEMENT_DYNAMICCREATEOBJECT(CAccessUser)
// 抽象工厂模式动态创建

// IDepartment(抽象产品类)
class CDatabaseDepartment :
    public CDynamicCreateObject
{
public:
    virtual void Insert(CDepartment* pDepartment) = 0;
    virtual CDepartment* GetDepartment(int nID) = 0;
};

// SQLServerDepartment(具体产品类)
class CSQLServerDepartment : public CDatabaseDepartment
{
// 抽象工厂模式动态创建
public:
    DECLARE_DYNAMICCREATEOBJECT()
// 抽象工厂模式动态创建
public:
    void Insert(CDepartment* pDepartment)
    {
        cout << "在SQL Server中给Department表增加一条记录。" << endl;
    }

    CDepartment* GetDepartment(int nID)
    {
        cout << "在SQL Server中根据ID得到Department表一条记录。" << endl;
        return NULL;
    }
};
// 抽象工厂模式动态创建
IMPLEMENT_DYNAMICCREATEOBJECT(CSQLServerDepartment)
// 抽象工厂模式动态创建

// AccessDepartment(具体产品类)
class CAccessDepartment : public CDatabaseDepartment
{
// 抽象工厂模式动态创建
public:
    DECLARE_DYNAMICCREATEOBJECT()
// 抽象工厂模式动态创建
public:
    void Insert(CDepartment* pDepartment)
    {
        cout << "在Access中给Department表增加一条记录。" << endl;
    }

    CDepartment* GetDepartment(int nID)
    {
        cout << "在Access中根据ID得到Department表一条记录。" << endl;
        return NULL;
    }
};
// 抽象工厂模式动态创建
IMPLEMENT_DYNAMICCREATEOBJECT(CAccessDepartment)
// 抽象工厂模式动态创建

//// 工厂方法模式举例--------------------
//// IFactory(抽象工厂类)
//class CFactory
//{
//public:
//    virtual CDatabaseUser* CreateDatabaseUser() = 0;
//    virtual CDatabaseDepartment* CreateDatabaseDepartment() = 0;
//};
//
//// SQLServerFactory(具体工厂类)
//class CSQLServerFactory : public CFactory
//{
//public:
//    virtual CDatabaseUser* CreateDatabaseUser()
//    {
//        return new CSQLServerUser();
//    }
//
//    virtual CDatabaseDepartment* CreateDatabaseDepartment()
//    {
//        return new CSQLServerDepartment();
//    }
//};
//
//// AccessFactory(具体工厂类)
//class CAccessFactory : public CFactory
//{
//public:
//    virtual CDatabaseUser* CreateDatabaseUser()
//    {
//        return new CAccessUser();
//    }
//
//    virtual CDatabaseDepartment* CreateDatabaseDepartment()
//    {
//        return new CAccessDepartment();
//    }
//};
//// 工厂方法模式举例--------------------
//
//// 简单工厂模式举例--------------------
//// DataAccess(简单工厂模式工厂类)
//class CDataAccess
//{
//private:
//    enum DATABASE{SQLServer, Access} ;
//    static const int m_nDB;
//
//public:
//    static CDatabaseUser* CreateDatabaseUser()
//    {
//        CDatabaseUser* pDatabaseUser = NULL;
//        switch (m_nDB)
//        {
//        case SQLServer:
//            pDatabaseUser = new CSQLServerUser();
//            break;
//
//        case Access:
//            pDatabaseUser = new CAccessUser();
//            break;
//        }
//        
//        return pDatabaseUser;
//    }
//
//    static CDatabaseDepartment* CreateDatabaseDepartment()
//    {
//        CDatabaseDepartment* pDatabaseDepartment = NULL;
//        switch (m_nDB)
//        {
//        case SQLServer:
//            pDatabaseDepartment = new CSQLServerDepartment();
//            break;
//
//        case Access:
//            pDatabaseDepartment = new CAccessDepartment();
//            break;
//        }
//
//        return pDatabaseDepartment;
//    }
//};
//
//const int CDataAccess::m_nDB = SQLServer;
//// 简单工厂模式举例--------------------

// 抽象工厂模式举例--------------------
// DataAccess(抽象工厂模式工厂类)
class CDataAccessAbstract
{
private:
    static string m_szUserName;
    static string m_szDepartmentName;
public:
    static CDatabaseUser* CreateDatabaseUser()
    {
        return (CDatabaseUser*)CDynamicCreateObject::MateStringThenCreateObject(m_szUserName);
    }
    
    static CDatabaseDepartment* CreateDatabaseDepartment()
    {
        return (CDatabaseDepartment*)CDynamicCreateObject::MateStringThenCreateObject(m_szDepartmentName);
    }
};
// 字符串从配置文件中读取功能略(并不难，不过不需要解析xml，直接读取整行，解析键值对就可以，键值对类似于：UserName = CAccessUser)
string CDataAccessAbstract::m_szUserName = "CAccessUser";
string CDataAccessAbstract::m_szDepartmentName = "CSQLServerDepartment";
// 抽象工厂模式举例--------------------


int main()
{
    CUser User;
    CDepartment Department;

    CDatabaseUser* pDatabaseUser = CDataAccessAbstract::CreateDatabaseUser();
    pDatabaseUser->Insert(&User);
    pDatabaseUser->GetUser(1);
    delete pDatabaseUser;

    CDatabaseDepartment* pDatabaseDepartment = CDataAccessAbstract::CreateDatabaseDepartment();
    pDatabaseDepartment->Insert(&Department);
    pDatabaseDepartment->GetDepartment(1);
    delete pDatabaseDepartment;

    system("pause");
    return 0;
}

输出结果：