#ifndef FACTORY_H
#define FACTORY_H
class Product;
class Factory
{
public:
virtual ~Factory() = 0;
virtual Product* CreateProduct() = 0;
protected:
Factory();
private:
};
class ConcreateFactory:public Factory
{
public:
~ConcreateFactory();
ConcreateFactory();
Product* CreateProduct();
protected:
private:
};
#endif // FACTORY_H
#include "Factory.h"
#include "Product.h"
#include <iostream>
using namespace std;
Factory::Factory()
{
}
Factory::~Factory()
{
}
ConcreateFactory::ConcreateFactory()
{
cout << "ConcreteFactory...." << endl;
}
ConcreateFactory::~ConcreateFactory()
{
}
Product* ConcreateFactory::CreateProduct()
{
return new ConcreteProduct();
}
#ifndef PRODUCT_H
#define PRODUCT_H
class Product
{
public:
virtual ~Product() = 0;
protected:
Product();
private:
};
class ConcreteProduct:public Product
{
public:
~ConcreteProduct();
ConcreteProduct();
protected:
private:
};
#endif // PRODUCT_H
#include "Product.h"
#include <iostream>
using namespace std;
Product::Product()
{
}
Product::~Product()
{
}
ConcreteProduct::ConcreteProduct()
{
cout << "ConcreteProduct......." << endl;
}
ConcreteProduct::~ConcreteProduct()
{
}
#include "Factory.h"
#include "Product.h"
#include <iostream>
int main(int argc, char *argv[])
{
Factory* fac = new ConcreateFactory(); //为什么是一个抽象类的指针?为什么要这样用?
Product* p = fac->CreateProduct();
return 0;
}
它的模型如下:模型的用意是,定义创建对象 的接口,封装对象的创建,将对象的创建放到子类中实现,使得具体化类的工作延迟到了子类中
这个模型的一些疑问解决:
首先要知道父类指针指向子类实例对象的知识点
几点知识:
-
无论父类里面有没有虚函数,都可以定义指向子类实例的父类指针.
-
如果父类里没有虚函数,则使用父类指针,只能访问父类的成员,而不能访问子类里的成员.
-
如果父类里的虚函数不是纯虚函数,且子类里没有重写该虚函数,则用父类指针访问该虚函数的时候,跟访问父类里的普通函数一样.
-
如果父类里的虚函数不是纯虚函数,且子类里重写了该虚函数,则用父类指针访问该虚函数的时候访问的是子类里重写后的函数.
-
如果父类里的虚函数是纯虚函数,则父类是个抽象类,子类要想能够被实例化,则必须重写该纯虚函数.用父类指针访问该纯虚函数的时候,访问到的是子类里重写了的函数.
-
再有一个要注意的是析构函数要声明为虚函数,这样在delete父类指针的时候,才会调用实例化的子类的虚函数,否则只会调用父类的析构函数,造成子类的剩余部分没被释放,从而造成内存的泄漏.
用C++比较好说明白:
1:指针的可访问性是由指针的定义决定的,比如说用BaseClass定义的指针,可访问的范围就是BaseClass的内存区域
2:允许用一个指向基类的指针指向派生类,由于被指向的对象的内存空间大于指针的可访问空间,所以这种向上映射是安全的
3:对象在调用虚函数的时候,是调用父类的函数还是调用派生类的函数,是和对象的类型有关的,比如说一个派生类B,其父类是A,则B的对象调用父类中被声明为VIRTUAL的函数时,被B所OVERRIDE的函数调用的是B里的函数,而B没有OVERRIDE的函数调用的是基类里的函数
http://zhidao.baidu.com/question/60594180.html
部分内容如下:
例如:
class a
{
public:
int aa
};
class b:public a
{
public:
int bb;
};
从内存的来看
如a
---------|
|占一个int数据大小--|
|----(aa数据)------|
|---------
而b则是
---------|---------
|占一个int数据大小--|占一个Int数据大小--|
|从a中继承而来------|---(bb数据----------|
|------------------
当定义一个基类类型的指针时
a *p;这时,这个指针指向的是a类型的数据
当p指针指向派生类的时候,因为p是a类型的指针,所以*p只解释为a类型数据的长度,即
————————-|---------
|占一个int数据大小--|占一个Int数据大小--|
|从a中继承而来------|-----(bb数据)-------|
|------------------
|------------|------------|
|-p只指向这个区域_--|
因此,当基类的指针(P)指向派生类的时候,只能操作派生类中从基类中继承过来的数据。
指向派生类的指针,因为内存空间比基类长,会导致严重了后果,所以不允许派生类的指针指向基类。而基类的指针可以指向派生类。
C++的多态性能解决基类指针不能操作派生类的数据成员的问题。