C++抽象基类的实例化(抽象工厂模式)

原创 2016年08月28日 21:14:32

今天学习设计模式《抽象工厂模式》,参考了两个博客:

http://blog.csdn.net/wuzhekai1985/article/details/6660462

http://www.cnblogs.com/wanggary/archive/2011/04/13/2015288.html

然后按照第二个博客的意见,应用类模板实现工厂类;中间出现一个不能实例化抽象基类的问题,通过查资料,然后另外新建一个工程实验后知道:

1,抽象类是不能初始化的(最基本的,大家都知道的)

2,如果抽象基类的派生类有哪怕只有一个函数没有实现,这个抽象基类仍然不能实例化;即需要将抽象基类中定义的虚接口函数全部在派生类中实现(说的不太专业。。。)

代码如下:

//core.h
#ifndef _CORE_H_
#define _CORE_H_

class Core{
public:
	Core(){}
	virtual ~Core(){}
	virtual void NumOfCore() = 0;
	virtual void SpeedOfCore() = 0;
	virtual void VersionOfCore() = 0;
};
#endif
<pre name="code" class="cpp">//multicore.h
#ifndef _MULTICORE_H_
#define _MULTICORE_H_

#include"core.h"
#include<iostream>
using namespace std;

class MultiCore :public Core{
public:
	MultiCore(){}
	~MultiCore(){}
	void NumOfCore(){
		cout << "multicore" << endl;
	}
	void SpeedOfCore(){
		cout << "speed fast" << endl;
	}
	virtual void VersionOfCore() = 0;
};
#endif
<pre name="code" class="cpp">//singlecore.h
#ifndef _SINGLECORE_H_
#define _SINGLECORE_H_

#include"core.h"
#include<iostream>
using namespace std;

class SingleCore :public Core{
public:
	SingleCore(){}
	~SingleCore(){}
	void NumOfCore(){
		cout << "singlecore" << endl;
	}
	void SpeedOfCore(){
		cout << "speed slow" << endl;
	}
	virtual void VersionOfCore() = 0;
};
#endif
<pre name="code" class="cpp">//newmulticore.h
#ifndef _NEWMULTICORE_H_
#define _NEWMULTICORE_H_

#include"multicore.h"

class NewMultiCore :public MultiCore{
public:
	NewMultiCore(){}
	~NewMultiCore(){}
	void VersionOfCore(){
		cout << "new multi version core" << endl;
	}
};

#endif
<pre name="code" class="cpp">//newsinglecore.h
#ifndef _NEWSINGLECORE_H_
#define _NEWSINGLECORE_H_

#include"singlecore.h"

class NewSingleCore :public SingleCore{
public:
	NewSingleCore(){}
	~NewSingleCore(){}
	void VersionOfCore(){
		cout << "new single version core" << endl;
	}
};
#endif
<pre name="code" class="cpp">//oldmulticore.h
#ifndef _OLDMULTICORE_H_
#define _OLDMULTICORE_H_

#include"multicore.h"

class OldMultiCore :public MultiCore{
public:
	OldMultiCore(){}
	~OldMultiCore(){}
	void VersionOfCore(){
		cout << "old multi version core" << endl;
	}
};

#endif
<pre name="code" class="cpp">//oldsinglecore.h
#ifndef _OLDSINGLECORE_H_
#define _OLDSINGLECORE_H_

#include"singlecore.h"

class OldSingleCore :public SingleCore{
public:
	OldSingleCore(){}
	~OldSingleCore(){}
	void VersionOfCore(){
		cout << "old single version core" << endl;
	}
};

#endif
<pre name="code" class="cpp">//factory.h
#ifndef _FACTORY_H_
#define _FACTORY_H_

#include"core.h"

class Factory{
public:
	Factory(){}
	virtual ~Factory(){}
	virtual Core* CreateSingleCore() = 0;
	virtual Core* CreateMultiCore() = 0;
};

#endif

<pre name="code" class="cpp">//newversionfactory.h
#ifndef _NEWVERSIONFACTORY_H_
#define _NEWVERSIONFACTORY_H_

#include"factory.h"

template<class T>
class NewVersionFactory :public Factory
{
public:
	NewVersionFactory();
	~NewVersionFactory();
	Core* CreateMultiCore();
	Core* CreateSingleCore();
};

template<class T>
NewVersionFactory<T>::NewVersionFactory(){}
template<class T>
NewVersionFactory<T>::~NewVersionFactory(){}
template<class T>
Core* NewVersionFactory<T>::CreateMultiCore()
{
	return new T;
}
template<class T>
Core* NewVersionFactory<T>::CreateSingleCore()
{
	return new T;
}

#endif
//oldversionfactory.h
#ifndef _OLDVERSIONFACTORY_H_
#define _OLDVERSIONFACTORY_H_

#include"factory.h"

template<class T>
class OldVersionFactory :public Factory
{
public:
	OldVersionFactory();
	~OldVersionFactory();
	Core* CreateMultiCore();
	Core* CreateSingleCore();
};

template<class T>
OldVersionFactory<T>::OldVersionFactory(){}
template<class T>
OldVersionFactory<T>::~OldVersionFactory(){}
template<class T>
Core* OldVersionFactory<T>::CreateMultiCore()
{
	return new T;
}
template<class T>
Core* OldVersionFactory<T>::CreateSingleCore()
{
	return new T;
}

#endif
//main.cpp
#include"core.h"
#include"factory.h"
#include"multicore.h"
#include"singlecore.h"
#include"newversionfactory.h"
#include"oldversionfactory.h"
#include"newmulticore.h"
#include"newsinglecore.h"
#include"oldmulticore.h"
#include"oldsinglecore.h"

void main()
{
	Factory* pFactoryMultiCore = new NewVersionFactory<NewMultiCore>();
	pFactoryMultiCore->CreateMultiCore()->NumOfCore();
	pFactoryMultiCore->CreateMultiCore()->SpeedOfCore();
	pFactoryMultiCore->CreateMultiCore()->VersionOfCore();
	delete pFactoryMultiCore;
	pFactoryMultiCore = NULL;

	Factory* pFactorySingleCore = new OldVersionFactory<OldSingleCore>();
	pFactorySingleCore->CreateSingleCore()->NumOfCore();
	pFactorySingleCore->CreateSingleCore()->SpeedOfCore();
	pFactorySingleCore->CreateSingleCore()->VersionOfCore();
	delete pFactorySingleCore;
	pFactorySingleCore = NULL;

}










                    

抽象工厂模式实例代码

  • 2014年01月15日 12:00
  • 12KB
  • 下载

c++ java 抽象工厂模式代码

  • 2016年12月31日 19:20
  • 417KB
  • 下载

C++设计模式——抽象工厂模式(含实例)

伟创力(世界500强企业),公司有笔记本生产车间、电视机车间、空调车间、电话生产等车间,各生产车间各行其责,生产出不同类型的产品。伟创力不再是生产单一产品的企业,而是生产出多种不同类型的产品,各产品属...
  • swqqcs
  • swqqcs
  • 2014年09月08日 20:35
  • 1693

抽象工厂模式的C++、Java实现

  • 2017年02月04日 21:06
  • 2.09MB
  • 下载

抽象工厂模式实例(C#)

抽象工厂的具体实例:   用Factory Method模式设计一个电视机工厂: 要求为每种品牌的电视机提供一个子工厂,如:海尔工厂专门负责生产海尔电视机,海信工厂专门负责生产海信电视机,如果需...

抽象工厂模式代码

  • 2017年12月17日 12:08
  • 11KB
  • 下载

抽象工厂模式

  • 2016年08月12日 06:56
  • 18KB
  • 下载

抽象工厂模式 (C++实现)

原文地址:   http://www.cnblogs.com/Kelvinshere/archive/2013/03/06/2947022.html    工厂模式其实不是太深奥,...
  • xxinliu
  • xxinliu
  • 2013年06月04日 16:13
  • 881
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++抽象基类的实例化(抽象工厂模式)
举报原因:
原因补充:

(最多只允许输入30个字)