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

#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;
}

 

它的模型如下：模型的用意是，定义创建对象 的接口，封装对象的创建，将对象的创建放到子类中实现，使得具体化类的工作延迟到了子类中

 

这个模型的一些疑问解决：

首先要知道父类指针指向子类实例对象的知识点

几点知识:

1. 无论父类里面有没有虚函数,都可以定义指向子类实例的父类指针.

2. 如果父类里没有虚函数,则使用父类指针,只能访问父类的成员,而不能访问子类里的成员.

3. 如果父类里的虚函数不是纯虚函数,且子类里没有重写该虚函数,则用父类指针访问该虚函数的时候,跟访问父类里的普通函数一样.

4. 如果父类里的虚函数不是纯虚函数,且子类里重写了该虚函数,则用父类指针访问该虚函数的时候访问的是子类里重写后的函数.

5. 如果父类里的虚函数是纯虚函数,则父类是个抽象类,子类要想能够被实例化,则必须重写该纯虚函数.用父类指针访问该纯虚函数的时候,访问到的是子类里重写了的函数.

6. 再有一个要注意的是析构函数要声明为虚函数,这样在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++的多态性能解决基类指针不能操作派生类的数据成员的问题。