C++面向对象之多态

一、多态的概念

        多态，通俗讲就是多种形态。在C++中，不同类型的对象去调用同一种方法或函数，会产生不同的结果，这种情况就称为多态。

        例如，抢微信红包。不同人（不同对象），抢同一个红包（同一种方法），但是抢到金额不同（不同的结果）。

二、多态的分类

        多态分为两种：静态多态和动态多态。

        静态多态：指的是函数重载和运算符重载。

        动态多态：指的是通过虚函数和派生类实现运行时多态。

下面将详细地加以解释

三、静态多态

       静态多态就是函数重载和运算符重载。

       所谓重载，就是同名，但是由于返回值类型或者参数不同，调用时产生不同的结果。

       为什么是静态呢？因为静态多态是在编译期间实现的。编译器在编译过程中，就已经确定了函数的地址（定下了执行同名函数中的哪一个）。因为编译器会根据函数形参的类型直接判断出要调用哪个函数，并且固定下来。

请看代码：

#include<iostream>

using namespace std;

class animal {
public:
	void speak() {
		cout << "动物在说话" << endl;
	}
};
class cat :public animal {
public:
	void speak() {
		cout << "小猫在说话" << endl;
	}
};
void dospeak(animal& L) {
	L.speak();
}
void test1() {
	cat L;
	dospeak(L);
}
int main() {
	test1();
	system("pause");
	return 0;
}

执行结果如下：

     从执行结果可以看到，调用的是animal类的speak函数。这是因为dospeak（）函数形参是指向animal类型的引用，编译器在编译中发现了这一点，从而固定了dospeak（）函数中调用的speak函数的地址，使他始终调用animal类中的speak函数。

     由于函数地址固定，所以称为静态多态。

四、动态多态

    一、引入

     从上面的代码可以看到，静态多态不够灵活。我们既然创建了一个cat类的对象，就想让dospeak函数中调用cat类的speak函数，然而静态多态做不到这一点。所以，由此引入了动态多态。有了动态多态，便可以根据输入参数的类型来调用不同的同名函数。

     二、动态多态条件

      动态多态的实现借助继承和虚函数。要求：

      1、必须通过基类的指针或引用调用函数

      2、被调用的函数必须是虚函数，并且在派生类中对虚函数进行了重写

      实际上这也是对动态多态的语法要求。

      理解条件：

      1、必须通过基类的指针或者引用来调用：

      即：参数是基类的指针或者引用。在实际调用时，可以输入此基类的派生类的指针或者引用。

      2、被调用的函数必须是虚函数，并且在派生类中对虚函数进行了重写：

      这个同名函数必须在基类中被声明为虚函数，并且派生类中重写这个函数

    三、虚函数

      虚函数：被virtual修饰的函数。

      虚函数语法为：virtual 返回值类型 函数名（）{函数体}

      一旦定义了虚函数，该基类的派生类中的同名函数都成虚函数，无论是否用virtual修饰。当然，还需要基类派生类中同名函数返回值类型，形参表都相同。

      虚函数只能是类中的成员函数，不能是普通函数或者静态函数。

      写虚函数时常见错误：

      1、无意的重写：在派生类中声明一个与基类某个虚函数具有相同签名（同返回值类型，形参表，const属性）的成员函数。

class animal {
public:
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};
class cat :public animal {
public:
	void speak() {
		cout << "小猫在说话" << endl;
	}
};

在上面的代码中，我们不想让cat类中的speak函数成为虚函数，但是由于基类定义了同标签的函数为虚函数，cat类中的speak函数被迫成为虚函数。

      2、虚函数签名不匹配：

class animal {
public:
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};
class cat :public animal {
public:
	virtual void speak(int a) {
		cout << "小猫在说话" << endl;
	}
};

我们本意是cat类中speak重写虚函数，但是由于形参不同，导致创建了一个新的虚函数，两个speak函数之间没有关联。

针对上述问题，解决方法：

1、函数声明后加上override，明确表面这个派生类的虚函数重写基类虚函数。这时如果签名不匹配就会报错提醒（override写在派生类函数声明）

class animal {
public:
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};
class cat :public animal {
public:
	virtual void speak(int a) override{
		cout << "小猫在说话" << endl;
	}
};

这里表示cat类中的虚函数是对基类虚函数的重写

2、关键字final 往往写在基类成员函数声明中，表明不希望这个虚函数被重写。这时如果在派生类中重写虚函数就会报错

补充：final也可以用在类中，表示不希望这个类被继承

class animal final {
public:
	virtual void speak() final {
		cout << "动物在说话" << endl;
	}
};
class cat :public animal {
public:
	virtual void speak(int a) {
		cout << "小猫在说话" << endl;
	}
};

这里final表示不希望animal类被继承，不希望虚函数被重写

四、虚函数重写

       虚函数重写：派生类中有一个与基类完全相同（返回值、形参、const属性都相同）的虚函数，则称派生类的虚函数重写了基类的虚函数。

       通过对虚函数的重写，就实现了动态多态。

       请看代码：

#include<iostream>

using namespace std;
class animal {
public:
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};
class cat :public animal {
public:
	virtual void speak() {
		cout << "小猫在说话" << endl;
	}
};
class dog :public animal {
public:
	virtual void speak() {
		cout << "小狗在说话" << endl;
	}
};
void dospeak(animal& L) {
	L.speak();
}
void test1() {
	cat L;
	dospeak(L);
}
void test2() {
	dog L;
	dospeak(L);
}
int main(){
	test1();
	test2();
	system("pause");
	return 0;
}

运行结果如下：

 可以发现，这一次cat类对象和dog类对象都调用了自己类中的方法，实现了多态。

五、虚函数重写的例外

1、协变：基类函数与派生类函数返回值类型不同的情况。

       前面讲到，虚函数重写要求基类和派生类虚函数签名必须是匹配的。但不绝对，有例外。协变就是其中一种。当基类虚函数返回值类型是基类的引用或指针，并且派生类虚函数返回值类型是该派生类的引用或指针，那么仍然可以实现多态

       强调：返回值类型可以协变，但是参数必须一样。

可以看一段代码：

#include<iostream>

using namespace std;

class animal {
public:
	virtual animal*  speak(animal &L) {
		cout << "动物在说话" << endl;
		return this;
	}
};
class cat :public animal {
public:
	virtual cat* speak(cat &L) {
		cout << "小猫在说话" << endl;
		return this;
	}
};
class dog :public animal {
public:
	virtual dog* speak(dog &L) {
		cout << "小狗在说话" << endl;
		return this;
	}
};
void dospeak(animal& L) {
	L.speak(L);
}
void test1() {
	cat L;
	dospeak(L);
}
void test2() {
	dog M;
	dospeak(M);
}
int main() {
	test1();
	test2();
	system("pause");
	return 0;
}

       这段代码和之前差别不大，只是修改了speak函数返回值类型，并且对应地对dospeak函数作了修改，但函数作用没变。执行后仍然实现了多态。

2、析构函数的重写：这是基类与派生类虚函数不同名的情况

      如果基类的虚构函数是虚函数，那么对于派生类，只要定义了析构函数，无论是否用virtual关键字修饰，析构函数都重写了基类的析构函数，尽管他们的函数名不同。

对于普通对象（通过类名 对象名 直接定义）而言，无论我们是不是声明虚函数，无论是不是多态，都可以正确调用。

对于动态申请的对象，必须声明是虚函数

请看下面的代码：

​
#include<iostream>

using namespace std;

class animal {
public:
	virtual ~animal() {
		cout << "~animal()" << endl;
	}
};
class cat :public animal {
public:
	virtual ~cat() {
		cout << "~cat()" << endl;
	}
};
class dog :public animal {
public:
	virtual ~dog() {
		cout << "~dog()的调用" << endl;
	}
};
int main(){
	animal L;
	cat M;
    animal *p1 =new animal;
    animal *p2 =new cat;
    delete p1;
    delete p2;
	return 0;
}

​

运行结果如下：

普通对象

动态申请的，并且如果将派生类对象地址赋值给基类类型的指针。这种情况下如果不声明virtual，对于派生类对象只析构基类的部分而不析构派生类的部分，造成内存泄漏，故而必须声明虚函数

六、动态多态原理

      动态多态实现原理：加上关键字virtual之后，该成员函数成为虚函数，同时基类中多出一个指针vfptr（虚函数指针）。vfptr指向基类中的vftable（虚函数表），虚函数表中存储着基类中虚函数的地址。如果派生类没有重写这个虚函数，那么继承时就会继承基类的vfptr，指向的是基类的vftable，也就是基类的虚函数。如果派生类重写虚函数，那么派生类的vftable（原先是基类的虚函数地址）会被替换为派生类的虚函数地址。

五、抽象类

概念：如果在虚函数的后面写上=0，那么这个函数就是纯虚函数。含有纯虚函数的类成为抽象类

virtual void speak()=0;

抽象类不能实例化对象。它的派生类继承后也不能实例化对象。如果想实例化对象，必须重写纯虚函数。（重写时不必写=0）

这体现的是接口继承。