3.抽象工厂模式

1.说明
请参阅第一篇文章
2.抽象工厂模式说明
抽象工厂模式：提供了一个创建一系列相关或相互依赖的对象的接口，而无需指定他们具体的类。
通俗：为创建不同的产品，或相同产品的不同型号，使用了不同的具体工厂来生产。
例如：富士康代工的有苹果的MAC，有IPhone，而华为代工魅族，nexus等。每个工厂可以有不同的产品，而这些产品可以进行可以进行抽象，工厂也可以进行抽象，所以就叫抽象工厂模式吧
优点：创建的实例过程和客户端分离，客户端通过接口来操作实例。产品的具体类名也被具体工厂隐藏。方便替换
缺点：当新增加一个产品时，改动很大，产品实例，工厂接口，具体工厂等都需改动
ex:抽象工厂增加某一产品，那么所有的实例化工厂类都会有改动，产品类也会增加
3.与简单工厂和工厂方法比较
个人还是喜欢简单工厂，虽然耦合性是最高，但胜在简单，抽象工厂适用于较为复杂的场景吧
4.UML

5.代码

//抽象工厂类
#ifndef __FACTORY_H
#define __FACTORY_H

#include "Book.h"
#include "Pad.h"

class CFactory
{
public:  
    virtual CBook* create_book() = 0;
    virtual CPad* create_pad() = 0; 
};
#endif
//富士康代工厂类
#ifndef __FOXFACTORY_H
#define __FOXFACTORY_H

#include "Factory.h"
#include "NoteBook.h"
#include "ThinkPad.h"

class CFoxFactory:public CFactory
{
public:
    virtual CBook* create_book()
    {
        return new CNoteBook();
    }
    virtual CPad* create_pad()
    {
        return new CThinkPad();
    }
};
#endif

//华为代工厂
#ifndef __HUAWEIFACTORY_H
#define __HUAWEIFACTORY_H

#include "Factory.h"
#include "MacBook.h"
#include "DellPad.h"

class CHuaweiFactory:public CFactory
{
public:
    CBook* create_book()  
    {
        return new CMacBook();
    }
    CPad* create_pad()  
    {
        return new CDellPad();
    }

};

#endif

//笔记本抽象类
#ifndef __BOOK_H
#define __BOOK_H

#include <iostream>

class CBook
{
public:
    virtual void playgame()=0;
    virtual void shutdown() = 0;
};

#endif

//具体笔记本1
#ifndef __NOTEBOOK_H
#define __NOTEBOOK_H

#include "Book.h"

class CNoteBook:public CBook
{
public:
    virtual void playgame()
    {
        std::cout<<"this is NoteBook playgame"<<std::endl;      
    }
    virtual void shutdown()
    {
        std::cout<<"this is NoteBook shutdown"<<std::endl;
    }
};

#endif

//具体笔记本2
#ifndef __MACBOOK_H
#define __MACBOOK_H

#include "Book.h"

class CMacBook:public CBook
{
public:
    virtual void playgame()
    {
        std::cout<<"this is mac playgame"<<std::endl;   
    }
    virtual void shutdown()
    {
        std::cout<<"this is mac shutdown"<<std::endl;
    }       
};

#endif

//pad抽象类
#ifndef __PAD_H
#define __PAD_H

#include <iostream>

class CPad
{
public:
    virtual void watch_moive() = 0;
    virtual void read_book() = 0;
};

#endif

//具体pad1

#ifndef __THINKPAD_H
#define __THINKPAD_H

#include "Pad.h"

class CThinkPad:public CPad
{
public:
    virtual void watch_moive()
    {
        std::cout<<"this is think-pad watch moive"<<std::endl;
    }   
    virtual void read_book()
    {
        std::cout<<"this is think-pad read book"<<std::endl;
    }
};
#endif

//具体pad2
#ifndef __DELLPAD_H
#define __DELLPAD_H

#include "Pad.h"

class CDellPad:public CPad
{
public:
    virtual void watch_moive()  
    {
        std::cout<<"this is dell watch-moive"<<std::endl;
    }
    virtual void read_book()  
    {
        std::cout<<"this is dell read-book"<<std::endl;
    }
};

#endif

//客户端

#include <iostream>
#include "HuaweiFactory.h"
#include "FoxFactory.h"
#include "Book.h"
#include "Pad.h" 

int main(void)
{
    CFactory* fact_one = new CHuaweiFactory();
    std::cout<<"this is my book-pad:"<<std::endl;
    CBook* mybook = fact_one->create_book();
    CPad* mypad = fact_one->create_pad();
    mybook->playgame();
    mybook->shutdown();
    mypad->watch_moive();
    mypad->read_book(); 

    std::cout<<"this is your book-pad"<<std::endl;
    CFactory* fact_two = new CFoxFactory();
    CBook* yourbook = fact_two->create_book();
    CPad* yourpad = fact_two->create_pad();
    yourbook->playgame();
    yourbook->shutdown();
    yourpad->watch_moive();
    yourpad->read_book();

    //说明：在析构函数中基类需要为虚析构函数中，此处并未实现
    delete fact_one;
    delete fact_two;
    delete yourbook;
    delete yourpad;
    delete mypad;
    delete mybook; 

    return 0;
}