学习笔记：关注C++设计模式之Factory模式

#ifndefFACTORY_H
#defineFACTORY_H

classProduct;

classFactory
{
public:
virtual~Factory()=0;
virtualProduct*CreateProduct()=0;

protected:
Factory();
private:
};

classConcreateFactory:publicFactory
{
public:
~ConcreateFactory();
ConcreateFactory();

Product*CreateProduct();

protected:
private:
};

#endif//FACTORY_H

#include"Factory.h"
#include"Product.h"
#include<iostream>
usingnamespacestd;

Factory::Factory()
{

}
Factory::~Factory()
{

}
ConcreateFactory::ConcreateFactory()
{
cout<<"ConcreteFactory...."<<endl;
}
ConcreateFactory::~ConcreateFactory()
{

}
Product*ConcreateFactory::CreateProduct()
{
returnnewConcreteProduct();
}

#ifndefPRODUCT_H
#definePRODUCT_H

classProduct
{
public:
virtual~Product()=0;

protected:
Product();

private:

};

classConcreteProduct:publicProduct
{
public:
~ConcreteProduct();
ConcreteProduct();

protected:
private:

};

#endif//PRODUCT_H

#include"Product.h"
#include<iostream>
usingnamespacestd;

Product::Product()
{

}
Product::~Product()
{

}

ConcreteProduct::ConcreteProduct()
{
cout<<"ConcreteProduct......."<<endl;
}
ConcreteProduct::~ConcreteProduct()
{

}

#include"Factory.h"
#include"Product.h"
#include<iostream>

intmain(intargc,char*argv[])
{
Factory*fac=newConcreateFactory();//为什么是一个抽象类的指针？为什么要这样用？
Product*p=fac->CreateProduct();

return0;
}

例如:
classa
{
public:
intaa
};

classb:publica
{
public:
intbb;
};

从内存的来看
如a
－－－－－－－－－|
|占一个int数据大小--|
|----（aa数据）------|
|－－－－－－－－－
而b则是
－－－－－－－－－|－－－－－－－－－
|占一个int数据大小--|占一个Int数据大小--|
|从a中继承而来------|---（bb数据----------|
|－－－－－－－－－－－－－－－－－－
当定义一个基类类型的指针时
a*p;这时，这个指针指向的是a类型的数据
当p指针指向派生类的时候，因为p是a类型的指针，所以*p只解释为a类型数据的长度，即
————————－|－－－－－－－－－
|占一个int数据大小--|占一个Int数据大小--|
|从a中继承而来------|-----（bb数据)-------|
|－－－－－－－－－－－－－－－－－－
|------------|------------|
|-p只指向这个区域_--|

因此，当基类的指针（P）指向派生类的时候，只能操作派生类中从基类中继承过来的数据。
指向派生类的指针，因为内存空间比基类长，会导致严重了后果，所以不允许派生类的指针指向基类。而基类的指针可以指向派生类。

C++的多态性能解决基类指针不能操作派生类的数据成员的问题。