• 抽象工厂模式


    思想:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。

    抽象工厂模式的类图:

    AbstractFactory-声明一个创建抽象产品对象的操作接口。

    ConcreteFactory-实现创建具体产品对象的操作。

    AbstractProduct-声明一类产品对象的接口。

    Product-实现AbstractProduct接口的,被相应具体工厂创建的产品对象。

    Client-仅使用AbstractFactory和AbstractProduct类声明的接口。

    代码实现:

     抽象和具体工厂的类放在一起,这样写的好处有很多,最后解释。

    /*学院的抽象工厂类*/		//相互依赖关系很强的类放在一起写的
    class DepartmentFactory{
    public:
    	DepartmentFactory(){}
    	~DepartmentFactory(){}
    	//创建教学办和软件工程系两个对象的纯虚函数
    	virtual Office* CreateOffice()=0;	//虚函数的写法
    	virtual Leader* CreateLeader()=0;
    	//抽象工厂的作用,统一好多产品对象的创建
    };
    /*建筑学院的抽象工厂类*/
    class ConstructDepartmentFactory:public DepartmentFactory{
    public:
    	ConstructDepartmentFactory(){}
    	~ConstructDepartmentFactory(){}
    	//ConstructOffice和ConstructLeader是相关的对象,无需具体的产品类来创建这个对象。
    	Office* CreateOffice()
    	{
    		return new ConstructOffice();
    	}
    	Leader* CreateLeader()
    	{
    		return new ConstructLeader();
    	}
    };
    /*计算机学院的工厂类*/
    class CSDepartmentFactory:public DepartmentFactory{
    public:
    	CSDepartmentFactory(){}
    	~CSDepartmentFactory(){}
    	//具体工厂的作用是用来创建对象的,产品的创建由具体的产品类来完成。
    	//具体产品类可能继承自抽象产品类
    	Office* CreateOffice()		//写错了,是CreateOffice
    	{
    		return new CSOffice();
    	}
    	Leader* CreateLeader()
    	{
    		return new CSLeader();
    	}
    };
    

    产品线和具体的产品族的类代码放在一起:

    //学院办公室抽象类
    class Office{
    public:
    	Office(){}
    	~Office(){}
    	virtual void CreateOffice()=0;	//虚函数的写法
    };
    //学院领导抽象类
    class Leader{
    public:
    	Leader(){}
    	~Leader(){}
    	virtual void CreateLeader()=0;
    };
    //计算机学院办公室类
    class CSOffice:public Office
    {
    public:
    	CSOffice(){}
    	~CSOffice(){}
    	
    	void CreateOffice()
    	{
    		cout<<"CSOffice"<<endl;
    	}
    };
    class ConstructOffice:public Office{
    public:
    	ConstructOffice(){}
    	~ConstructOffice(){}
    	void CreateOffice()
    	{
    		cout<<"ConstructOffice"<<endl;
    	}
    };
    class CSLeader:public Leader{
    public:
    	CSLeader(){}
    	~CSLeader(){}
    	void CreateLeader()
    	{
    		cout<<"CSLeader"<<endl;
    	}
    };
    

    测试的代码:

    CSDepartmentFactory *df=new CSDepartmentFactory;
    df->CreateOffice()->CreateOffice();	//只是创建了对象,还需要继续调用
    df->CreateLeader()->CreateLeader();
    	
    ConstructDepartmentFactory *dy=new ConstructDepartmentFactory;
    dy->CreateOffice()->CreateOffice();
    dy->CreateLeader()->CreateLeader();
    

    测试结果的图片:

    总结经验和引出的问题:

    1、依赖关系很紧密的类定义放在一起,这样可以避免复杂的头文件循环依赖问题。

    2、C++工程只编译源文件,需要的时候才编译头文件。

    3、虚函数和纯虚函数的写法不一样。

    4、抽象工厂模式是创建对象的模式,最后的调用还需要用指针来调用相关的函数。

    引出的C++的问题:

    1、C++命名空间。

    2、C++异常处理。

    3、C++单元测试。

    4、C++宏定义的用法。

    5、C++网络编程。

    6、C++多线程问题。

    7、C++虚函数和纯虚函数的用法,这个比较有料。

    8、C++标准库和Boost库。

    9、QT

    这些问题会在后续的博文中给出答案。

  • 相关阅读:
    nodejs入门学习笔记一——一个完整的http路由服务实现
    安装centos虚拟机
    test
    sql单列合并
    linux系统的安全小知识
    建造者模式组装mybatis参数Example()
    Https网站搭建——通过https://localhost:8443访问tomcat首页
    妈妈再也不用担心我找不到spring源码了!
    Webpack --- 模块打包器
    CSS3弹性盒---怪异盒
  • 原文地址:https://www.cnblogs.com/fistao/p/3015646.html
Copyright © 2020-2023  润新知