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

一、纯虚函数

          虚函数是多态是实现多态的前提，如果我们需要在基类中定义共同的结构，那么接口就需要定义成虚函数。但是很多情况下基类的接口是无法实现的，比如形状类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;
}