三十、纯虚函数、抽象类、多态、简单工厂模式

一、纯虚函数
          虚函数是多态是实现多态的前提，如果我们需要在基类中定义共同的结构，那么接口就需要定义成虚函数。但是很多情况下基类的接口是无法实现的，比如形状类Shape，定义一个Draw方法。很明显这个方法没法实现，因为我们可以画出圆，正方形，但是不能画出"形状"。此时我们可以将这些接口定义成虚函数。

          在基类中不能给出有意义的虚函数定义，这时可以把它说明成纯虚函数，把它的定义留给派生类来做，如果派生类没有实现，那么派生类也是纯虚函数，纯虚函数不需要实现
纯虚函数定义：
  class 类名{
       virtual 返回值类型 函数名(参数表) = 0；
    };
二、简单工厂模式
          工厂方法模式（Factory method pattern）是一种实现了“工厂”概念的面向对象设计模式。就像其他创建型模式一样，它也是处理在不指定对象具体类型的情况下创建对象的问题。工厂方法模式的实质是“定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。

纯虚函数和简单工厂模式示例：

二、抽象类
          包含纯虚函数的类我们称作抽象类。

作用：抽象类为抽象和设计的目的而声明，将有关的数据和行为组织在一个继承层次结构中，保证派生类具有要求的行为。
对于暂时无法实现的函数，可以声明为纯虚函数，留给派生类去实现。
注意：

抽象类只能作为基类来使用。(因为抽象类不能创建对象，只能被派生类实现)
构造函数不能是虚函数，析构函数可以是虚函数。
抽象类不能用于直接创建对象实例，可以声明抽象类的指针和引用
可使用指向抽象类的指针支持运行时多态性
派生类中必须实现基类中的纯虚函数，否则它仍将被看作一个抽象类
简单工厂模式和抽象类示例：

#include <iostream>
#include <vector>
#include <string>
using namespace std;

class Shape
{
public:
virtual void Draw() = 0;
virtual ~Shape() {}
};

class Circle : public Shape
{
public:
void Draw()
{
cout<<"Circle::Draw() ..."<<endl;
}
~Circle()
{
cout<<"~Circle ..."<<endl;
}
};

class Square : public Shape
{
public:
void Draw()
{
cout<<"Square::Draw() ..."<<endl;
}
~Square()
{
cout<<"~Square ..."<<endl;
}
};

class Rectangle : public Shape
{
public:
void Draw()
{
cout<<"Rectangle::Draw() ..."<<endl;
}
~Rectangle()
{
cout<<"~Rectangle ..."<<endl;
}
};

void DrawAllShapes(const vector<Shape*>& v)
{
vector<Shape*>::const_iterator it;
for (it=v.begin(); it!=v.end(); ++it)
{
(*it)->Draw();
}
}

void DeleteAllShapes(const vector<Shape*>& v)
{
vector<Shape*>::const_iterator it;
for (it=v.begin(); it!=v.end(); ++it)
{
delete(*it);
}
}

// 简单工厂模式
class ShapeFactory
{
public:
static Shape* CreateShape(const string& name)
{
Shape* ps = 0;
if (name == "Circle")
{
ps = new Circle;
}
else if (name == "Square")
{
ps = new Square;
}
else if (name == "Rectangle")
{
ps = new Rectangle;
}

return ps;
}
};

int main(void)
{
//Shape s;		//Error,不能实例化抽象类
vector<Shape*> v;
//Shape* ps;
//ps = new Circle;
//v.push_back(ps);
//ps = new Square;
//v.push_back(ps);
//ps = new Rectangle;
//v.push_back(ps);
Shape* ps;
ps = ShapeFactory::CreateShape("Circle");
v.push_back(ps);
ps = ShapeFactory::CreateShape("Square");
v.push_back(ps);
ps = ShapeFactory::CreateShape("Rectangle");
v.push_back(ps);

DrawAllShapes(v);
DeleteAllShapes(v);

return 0;
}

三、多态好处

1、多态性有助于更好地对程序进行抽象

控制模块能专注于一般性问题的处理
具体的操作交给具体的对象去做

2、多态性有助于提高程序的可扩展性

可以把控制模块与被操作的对象分开
可以添加已定义类的新对象，并能管理该对象
可以添加新类（已有类的派生类）的新对象，并能管理该对象
四、虚析构函数
          前面我们讲过析构函数可以声明为虚函数，这样我们delete 基类指针的时候，就会释放基类指针的指向的对象的内存。也就是说，程序会根据基类指针指向的对象的类型确定要调用的析构函数。如果基类的析构函数为虚函数，那么所有派生类的析构函数都是虚函数。但是构造函数不得是虚函数，这个在前面也已经讲过。
          最后析构函数还可以是纯虚的，它的使用场景是：对于一个没有任何接口的类，如果想要将它定义成抽象类，只能将虚析构函数声明为纯虚的，通常情况下在基类中纯虚函数不需要实现，但是纯虚析构函数要给出实现。（给出一个空的实现即可）

示例：

#include <iostream>
using namespace std;
class Base
{
public:
virtual ~Base() = 0
{
}
};

class Drived : public Base
{
};

int main(void)
{
Drived d;
return 0;
}