黑马程序员c++ 多态

多态的基本语法

多态是c++面向对象的三大特性之一

多态分为两类：

• 静态多态：函数重载 和 位运算符重载 属于静态多态，复用函数名
• 动态多态：派生类和函数实现运行时多态

静态多态和动态多态区别：

• 静态多态的函数地址早绑定 - 编译阶段确定函数地址
• 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

下面通过案例对多态进行讲解

#include <iostream>

using namespace std;

class Animal
{
public:
	void Speak()
	{
		cout << "动物在说话" << endl;
	}
};

class Cat : public Animal
{
public:
	void Speak()
	{
		cout << "小猫在说话" << endl;
	}
};

class Dog : public Animal
{
public:
	void Speak()
	{
		cout << "小狗在说话" << endl;
	}
};

void Speak(Animal &animal)	//在c++中，子类可以直接赋值给父类的引用 
{
	animal.Speak();
	//父类的函数与子类的同名函数重载，属于静态多态，在编译阶段确定地址
	//所以这里只要是Animal类都会调用Animal类的speak函数
}

int main()
{
	Cat cat;
	Dog dog;
	
	Speak(cat);
	Speak(dog);
	
	return 0;
}

 这里程序调用的结果是 动物在说话，这是因为父类与子类的同名函数重载在c++中属于静态多态，函数的地址在编译阶段确定，所以只要是Animal类，都会调用Animal类的speak函数

但这里我们传入的是子类对象，目的调用子类speak函数，所以我们就不能早早的在编译时确定Animal类的Speak函数地址，而要让子类对象传入是在确定函数地址，这时我们就可以在Animal类的Speak成员前加上 virtual 关键字，使其成为虚函数，在程序运行时确定函数地址。

#include <iostream>

using namespace std;

class Animal
{
public:
	virtual void Speak() //加上virtual关键字，使用动态多态，使函数地址在程序运行时确定
	{
		cout << "动物在说话" << endl;
	}
};

class Cat : public Animal
{
public:
	void Speak()
	{
		cout << "小猫在说话" << endl;
	}
};

class Dog : public Animal
{
public:
	void Speak()
	{
		cout << "小狗在说话" << endl;
	}
};

void Speak(Animal &animal)
{
	animal.Speak();
}

int main()
{
	Cat cat;
	Dog dog;
	
	Speak(cat);
	Speak(dog);
	
	return 0;
}

 我们可以看到，加上 virtual 关键字，使之成为虚函数，再调用虚函数，就会打印子类函数内容。

动态多态实现条件： 

• 继承关系
• 子类重写父类虚函数

虚函数：在函数返回值前加virtual

重写：函数返回值类型，函数名和参数列表都完全相同

动态多态如何使用

• 父类的指针或引用，指向子类对象

在上面的代码中，动态多态的使用体现在全局域中Speak函数的参数列表，传入子类对象赋值给列表中的父类引用，在调用父类的虚函数，就实现了动态多态，使函数晚绑定。

 多态原理剖析

我们将父类函数前的 virtual 关键字去掉，这时父类的函数变成了一个普通的成员函数，不属于类的对象上，输出类的大小为 1.

#include <iostream>

using namespace std;

class Animal
{
public:
	void Speak()
	{
		cout << "动物在说话" << endl;
	}
};

void test()
{
	cout << sizeof(Animal) << endl;
}

int main()
{
	test();
	
	return 0;
}

 现在我们再把virtual关键字加上输出类的大小。

#include <iostream>

using namespace std;

class Animal
{
public:
	virtual void Speak()
	{
		cout << "动物在说话" << endl;
	}
};


void test()
{
	cout << sizeof(Animal) << endl;
}

int main()
{
	test();
	
	return 0;
}

 运行程序得到输出结果为 4.这是因为原本的成员函数变成了一个指针，而指针的大小为四，我们将这个指针称为vfpty（vitual function pointer）虚函数（表）指针，指向一个虚函数表（vftable）在表的内部会记录虚函数的地址，也就是Animal类中Speak()函数的地址。

 因为子类继承了父类，所以子类也会有一个虚函数指针指向一个虚函数表，但这个虚函数表中依然记录着父类Animal::Speak()的地址。

但当我们在子类中重写Speak()函数，虚函数表中的父类的函数地址就会被子类所替换，但父类记录的函数地址没有被替换。

 

这是我们用父类的指针或者引用子类的对象时，就会发生多态，调用通过父类对象就可以通过虚函数表中的函数地址调用子类函数。

Cat cat;
Animal &animal = cat;
animal.Speak();

 我们可以用开发人员命令工具看看类的布局来验证这一结论

纯虚函数和抽象类

在多态中， 通常父类中的虚函数的实现是毫无意义的，主要都是调用子类重写的内容。

因此可以将虚函数改为纯虚函数

纯虚函数语法： virtual 返回值类型 函数名 （参数列表）= 0；

当类中有了纯虚函数，这个类也被称为抽象类。

抽象类的特点：

• 无法实例化对象。
• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类。

#include <iostream>

using namespace std;

class Base
{
public:
	
	virtual int func() = 0;	//纯虚函数声明 
};

class Son : public Base
{
public:
	
	int func()	//继承抽象类的子类必须重写纯虚函数，否则也为抽象类，不能实例化对象 
	{
		cout << "子类函数调用" << endl; 
	}
};

test()
{
//	Base b 抽象类不能实例化对象
	Base *b = new Son;
	b -> func(); 
}

int main()
{
	test();
	
	return 0;
}

虚析构与纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构。

虚析构与纯虚析构共性

• 都可以用父类指针释放子类对象
• 都需要有具体的函数实现

虚析构与纯虚析构区别

• 如果是纯虚析构，该类属于抽象类，无法实例化对象。

虚析构语法：

        virtual~类名（）{}

纯虚析构语法：

        virtual~类名（） = 0；

#include <iostream>
#include <string>

using namespace std;

class Animal
{
public:
	
	Animal()
	{
		cout << "父类构造函数调用" << endl; 
	}
	virtual void Speak() = 0;
	
	~Animal()
	{
		cout << "父类析构函数调用" << endl;
	}
};

class Cat : public Animal
{
public:
	
	Cat(string name)
	{
		cout << "子类构造函数调用" << endl;
		m_Name = new string(name);
	}
	
	void Speak()
	{
		cout << *m_Name << "在说话" << endl;
	}
	
	~Cat()
	{
		cout << "子类析构函数调用" << endl;
		if(m_Name != NULL)
		{
			delete m_Name;
			m_Name = NULL;
		}
	}
	
	string *m_Name = NULL;
};

void test()
{
	Animal *animal = new Cat("Tom"); //可以在new的同时给对象初始化
	animal -> Speak();
	delete animal;
}

int main()
{
	test();
	
	return 0;
}

 在上面的代码中，Cat类是Animal的一个子类，并且在执行构造函数时会在堆区开辟空间。

执行测试案例，我们将实例化的Cat对象创建在堆区，由于Animal是Cat的父类，会先调用Animal的构造函数，再调用Cat的构造函数，最后释放堆区空间，但问题是，由于我们用Animal指针释放堆区空间，所以这里不会执行Cat的析构函数，只会执行Animal的析构函数。

没有执行Cat的析构函数，没有释放m_Name申请的堆区空间就会造成内存泄漏的问题。

由此我们就要将父类的析构函数变为虚函数，通过父类指针指向子类函数，来解决这个问题。 

#include <iostream>
#include <string>

using namespace std;

class Animal
{
public:
	
	Animal()
	{
		cout << "父类构造函数调用" << endl; 
	}
	virtual void Speak() = 0;
	
	virtual ~Animal()
	{
		cout << "父类析构函数调用" << endl;
	}
};

class Cat : public Animal
{
public:
	
	Cat(string name)
	{
		cout << "子类构造函数调用" << endl;
		m_Name = new string(name);
	}
	
	void Speak()
	{
		cout << *m_Name << "在说话" << endl;
	}
	
	~Cat()
	{
		cout << "子类析构函数调用" << endl;
		if(m_Name != NULL)
		{
			delete m_Name;
			m_Name = NULL;
		}
	}
	
	string *m_Name = NULL;
};

void test()
{
	Animal *animal = new Cat("Tom");
	animal -> Speak();
	delete animal;
}

int main()
{
	test();
	
	return 0;
}

我们也可以将父类的析构函数写为纯虚函数，但因为虚析构函数的函数体不能为空，所以我们将在类内声明纯虚析构函数，在类外写函数实现。

具体实现如下：

class Animal
{
public:
	
	Animal()
	{
		cout << "父类构造函数调用" << endl; 
	}
	virtual void Speak() = 0;
	
//	virtual ~Animal()
//	{
//		cout << "父类析构函数调用" << endl;
//	}

	virtual ~Animal() = 0;
};

Animal:: ~Animal()
{
	cout << "父类析构函数调用" << endl;
}

• 普通的纯虚函数不能有函数实现，但纯虚析构函数要有
• 拥有纯虚析构函数的类也属于抽象类，不能实例化
• 如果子类没有堆区数据，可以不写为虚析构或纯虚析构。
• 应用场景：子类中有成员维护堆区空间，要在析构函数中释放，在使用多态时，要将父类析构函数写为虚函数。