设计模式——抽象工厂模式

1. 抽象工厂模式
   适用问题：创建一组相似或有联系的对象，并为其提供接口。
   （1） 实现过程。其过程与工厂方法模式基本一致，父类提供接口，把实现延时到子类，其实现的方式与工厂方式是相同的（有一个产品类返回值的函数，返回的是具体产品的对象，一般new出来），不同之处在于，一个工厂它创建的是一组产品，有几种，但他们是相关联的（游戏中初级怪的不同种类等等）。

以下是我测试代码：

//virFcMod.h
#ifndef VIR_FC_MOD
#define VIR_FC_MOD
#pragma once
#include"mainClass.h"
class virFc_Mod
{
public:
    virFc_Mod();
    ~virFc_Mod();
    virtual bool creatClassA(mainClass * &pmain) = 0;
    virtual bool creatClassB(mainClass * &pmain) = 0;
private:

};


#endif

//virFc_Mod.cpp
#include"virFc_Mod.h"

virFc_Mod::virFc_Mod()
{
}

virFc_Mod::~virFc_Mod()
{
}

//FcMOd1.h
#ifndef FC_MOD1
#define FC_MOD1
#include"virFc_Mod.h"
#include"chClassA1.h"
#include"chClassB1.h"

class Fc_Mod1:public virFc_Mod
{
public:
    Fc_Mod1();
    ~Fc_Mod1();
    bool creatClassA(mainClass * &pmain);
    bool creatClassB(mainClass * &pmain);

private:

};


#endif

//Fc_Mod1.cpp
#include"Fc_Mod1.h"

Fc_Mod1::Fc_Mod1()
{
}

Fc_Mod1::~Fc_Mod1()
{
}


bool Fc_Mod1::creatClassA(mainClass * &pmain)
{

    pmain = new chClassA1();

    return true;
}

bool Fc_Mod1::creatClassB(mainClass * &pmain)
{
    pmain = new chClassB1();
    return true;
}

//Fc_Mod2.h
#ifndef FC_MOD2
#define FC_MOD2
#include"virFc_Mod.h"
#include"chClassA2.h"
#include"chClassB2.h"

class Fc_Mod2 :public virFc_Mod
{
public:
    Fc_Mod2();
    ~Fc_Mod2();
    bool creatClassA(mainClass * &pmain);
    bool creatClassB(mainClass * &pmain);

private:

};


#endif

//Fc_Mod2.cpp
#include"Fc_Mod2.h"

Fc_Mod2::Fc_Mod2()
{
}

Fc_Mod2::~Fc_Mod2()
{
}


bool Fc_Mod2::creatClassA(mainClass * &pmain)
{
    pmain = new chClassA2();
    return true;
}

bool Fc_Mod2::creatClassB(mainClass * &pmain)
{
    pmain = new chClassB2();
    return true;
}

//mainClass.h
#ifndef MAIN_CLASS
#define MAIN_CLASS
#include<iostream>
#pragma  once

using namespace std;

class mainClass
{
public:
    mainClass();
    ~mainClass();
    virtual bool say(char * string)=0;
    virtual  bool talk(char *string) = 0;
private:

};



#endif

//main.cpp
#include"mainClass.h"

mainClass::mainClass()
{
}

mainClass::~mainClass()
{
}

//main_ClassA.h
#ifndef MAIN_CLASSA
#define MAIN_CLASSA
#pragma once
#include"stdafx.h"
#include"mainClass.h"

class mainClassA: virtual public mainClass
{
public:
    mainClassA();
    ~mainClassA();

private:

};



#endif

//mianClassA.cpp
#include"mainClassA.h"

mainClassA::mainClassA()
{
}

mainClassA::~mainClassA()
{
}

//mianClassB.h
#ifndef MAIN_CLASSB
#define MAIN_CLASSB
#pragma once

#include"mainClass.h"

class mainClassB:virtual public mainClass
{
public:
    mainClassB();
    ~mainClassB();

private:

};


#endif

//mainClassB.cpp
#include"mainClassB.h"

mainClassB::mainClassB()
{
}

mainClassB::~mainClassB()
{
}

//chClassA1.h
#ifndef CH_CLASS_A1
#define CH_CLASS_A1
#include"mainClassA.h"
class chClassA1 : public mainClassA
{
public:
    chClassA1();
    ~chClassA1();
    bool talk(char *string);
    bool say(char * string);

private:

};


#endif

//mainClassA1.cpp
#include"chClassA1.h"

chClassA1::chClassA1()
{
}

chClassA1::~chClassA1()
{
}



bool chClassA1::say(char * string)
{
    printf("hello! %s", string);
    return   true;
}
bool chClassA1::talk(char *string)
{
    return true;
}

//chClassA2.h
#ifndef CH_CLASS_A2
#define CH_CLASS_A2

#include"mainClassA.h"

class chClassA2 : public mainClassA
{
public:
    chClassA2();
    ~chClassA2();
    bool say(char * string);
    bool talk(char *string);
private:

};


#endif

//chClassA2.cpp
#include"chClassA2.h"

chClassA2::chClassA2()
{
}

chClassA2::~chClassA2()
{
}


bool chClassA2::say(char * string)
{
    printf("hello!  %s", string);
    return true;
}

bool chClassA2::talk(char *string)
{
    return true;
}

//chClassB1.h
#ifndef CH_CLASS_B1
#define CH_CLASS_B1
#include"mainClassB.h"
class chClassB1 : public    mainClassB
{
public:
    chClassB1();
    ~chClassB1();
    bool talk(char *string);
    bool say(char * string);
private:

};



#endif

//chClassB1.cpp
#include"chClassB1.h"

chClassB1::chClassB1()
{
}

chClassB1::~chClassB1()
{
}

bool chClassB1::talk(char * string)
{
    printf("你好！ %s", string);
    return true;
}

bool chClassB1::say(char * string)
{
    printf("hello!  %s", string);
    return true;
}

//chClassB2.h
#ifndef CH_CLASS_B2
#define CH_CLASS_B2
#include"mainClassB.h"
class chClassB2 : public    mainClassB
{
public:
    chClassB2();
    ~chClassB2();
    bool talk(char *string);
    bool say(char * string);
private:

};



#endif

//chClassB2.cpp
#include"chClassB2.h"

chClassB2::chClassB2()
{
}

chClassB2::~chClassB2()
{
}

bool chClassB2::talk(char * string)
{
    printf("你好！ %s", string);
    return true;
}

bool chClassB2::say(char * string)
{
    printf("hello!  %s", string);
    return true;
}

//demo.cpp
#include"mainClass.h"
#include"virFc_Mod.h"
#include"Fc_Mod1.h"
#include"Fc_Mod2.h"


int _tmain(int argc, _TCHAR* argv[])
{

    virFc_Mod *pfc = new Fc_Mod1();
    mainClass* pmain=nullptr;
    pfc->creatClassA(pmain);
    pmain->say("nihao");
    pfc->creatClassB(pmain);

    return 0;
}

调试结果为：