【C++ 学习】多态的基础和原理（10）

前言
1. 概念
2. 多态的定义及实现
- 2.1 多态的构成条件
- 2.2 虚函数
- 2.3 虚函数重写
- 2.4 虚函数重写的例外
- - 2.4.1 协变
  - 2.4.1 析构函数的重写
- 2.5 多态调用和普通调用
- 2.6 函数重写/函数隐藏/函数重载的对比
- - 2.6.1 函数重写
  - 2.6.2 函数隐藏
  - 2.6.3 函数重载
- 2.7 C++11 final 和override
3. 抽象类
- 3.1 概念
- 3.2 接口继承和实现继承
4. 虚函数表

前言

本内容适合有C++继承基础的同学学习，本节讲解C++多态的基础知识和多态的实现原理，适合同学学习和更加深入的理解多态。

1. 概念

在 C++ 中，多态（Polymorphism）是一种面向对象编程的重要特性，允许一个接口以多种形式存在。多态性分为两种主要类型：编译时多态（静态多态）和运行时多态（动态多态）

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子：
在这里插入图片描述
为什么会在我的界面会显示开通VIP会员免费看呢？
假设，普通用户有一个函数 Watch_Video(){ （代码内容是不可观看VIP电影）}
当你升级VIP后，你也是这个函数 Watch_Video()，但是内容发生了改变，Watch_Video(){ （代码内容是可以观看VIP电影）}。当普通用户和VIP用户同时大开一个VIP电影，系统调用的都是 Watch_Video()函数，但是显示给用户的是不同的内容，这是用什么实现的呢？
答案是：用多态实现。

2. 多态的定义及实现

2.1 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Member继承了Person。Person对象不能看VIP电影，Member对象可以看VIP电影。
那么在继承中要构成多态还有两个条件：

必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

在这里插入图片描述

2.2 虚函数

虚函数：即被 virtual 修饰的类成员函数称为虚函数。虚函数允许派生类重写基类中的函数，从而在运行时根据对象的实际类型调用相应的函数。

代码演示：

class Person 
{
public:
	//用virtual修饰的函数
	virtual void Watch_video()
	{
		cout << "您无法观看，请开通会员！" << endl;
	}

};

2.3 虚函数重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数 (即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

代码演示：

class Person 
{
public:
	//用virtual修饰的函数
	virtual void Watch_video()
	{
		cout << "您无法观看，请开通会员！" << endl;
	}

};

class Member :public Person
{
public:
	//用virtual修饰的函数
	virtual void Watch_video()
	{
		cout << "观看中~~" << endl;
	}
   /*void Watch_video() 
   { 
       cout << "观看中~~" << endl; 
   }*/
};

/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议
这样使用*/
/*void BuyTicket() { cout << "买票-半价" << endl; }*/

2.4 虚函数重写的例外

2.4.1 协变

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指
针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解）

代码演示：

// 返回值不同的例子：
// 协同：父子类继承关系的指针或则引用，可以是 自己的继承关系，也可以是其他的继承关系
class A 
{
public:
	A(){}
};

class B :public A
{
public:
	B(){}
};

class Person
{
public:
	Person()
	{}
// 返回值为基类/派生类的指针或引用
	virtual A* Watch_video()
	{
		cout << "您无法观看，请开通会员!" << endl;
		return nullptr;
	}

};

class Member :public Person
{
public:
	Member()
	{}
// 返回值为基类/派生类的指针或引用
	virtual B* Watch_video()
	{
		cout << "观看中~~" << endl;
		return nullptr;
	}
};

void Watch(Person& p)
{
	p.Watch_video();
}

int main()
{
	//注册腾讯会员后不开会员
	Person per;
	//看VIP视频
	Watch(per);

	//注册腾讯视频后开会员
	Member mem;
	//看VIP视频
	Watch(mem);


	return  0;
}

2.4.1 析构函数的重写

类不同，析构函数名字就会不同。那么怎么符合析构函数重写三同的条件呢？
答：如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成 destructor。

同学们猜一猜下列的例子执行会打印什么？

同学们猜一猜下列的执行会打印出什么？为什么？
class Person
{
public:
	~Person()
	{
		cout << "~Person()" << endl;
	}
};

class Member : public Person
{
public:
	~Member()
	{
		cout << "~Member()" << endl;
	}
};

int main()
{
	Person* p = new Person;
	delete p;

	p = new Member;
	delete p;

	return 0;
}

答案：
在这里插入图片描述
这是为什么呢？

这是我们想要的多态调用结果吗？
答：肯定不想要这样的结果，这样会发生内存泄漏。

怎么解决呢？
前面已经说了，对析构函数有特殊化处理，其实析构函数的名字都是 destructor ，只要在析构函数名前加上 virtual 修饰即可构成虚函数重写。

代码演示：

class Person
{
public:
   // 析构函数用 virtual 修饰
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};

class Member : public Person
{
public:
     //虚函数重写
	/* virtual */  ~Member()
	{
		cout << "~Member()" << endl;
	}
};


int main()
{
	Person* p = new Person;
	delete p;

	cout << "-----------" << endl;
	p = new Member;
	delete p;

	return 0;
}

注：在 new 场景下才会用到虚的析构函数。

2.5 多态调用和普通调用

多态调用：调用指针或者引用指向的对象。指向父类就调用父类的函数，指向子类就调用子类的函数。
普通调用：调用函数的类型是谁，就调用这个类型的函数。

代码演示：

// 没有多态的继承
class Person
{
public:
	//没有virtual修饰
     void Watch_video()
	{
		cout << "您无法观看，请开通会员!" << endl;
	}
};


class Member: public Person
{
public:
	//没有virtual修饰
	void Watch_video()
	{
		cout << "正在观看中" << endl;
	}
};


void Watch(Person& p)
{
	// 调用对象的类型是Person
	// 调用的函数都是Person类的Watch_video()
	p.Watch_video();
}


int main()
{
	Person per;
	Watch(per);

	Member mem;
	Watch(mem);

	return 0;
}

2.6 函数重写/函数隐藏/函数重载的对比

在这里插入图片描述

2.6.1 函数重写

函数重写（Function Overriding）是面向对象编程中的一个重要概念，特别是在继承关系中。函数重写允许派生类提供与基类中同名函数不同的实现。通过函数重写，派生类可以覆盖基类中的方法，从而实现特定的行为。这在多态性中起着关键作用。

同学们观看下列代码，回答打印的是什么？为什么？

class Person
{
public:
	virtual void Print(int n = 6)
	{
		cout << n << endl;
	}

private:
	int _n;
};


class Member: public Person
{
public:
	virtual void Print(int n = 0)
	{
		cout << n << endl;
	}
};

//调用多态
void Watch(Person& p)
{
	p.Print();
}


int main()
{
	Person per;
	Watch(per);

	Member mem;
	Watch(mem);

	return 0;
}

答案：
在这里插入图片描述
打印两个6！编译器坏了？同学，你还是没有理解函数重写的含义。函数重写，处重写的是实现方法，而调用的还是基类函数的接口。

2.6.2 函数隐藏

函数隐藏是指在派生类中定义了一个与基类中同名但参数列表不同的函数。在这种情况下，派生类中的函数会隐藏基类中的同名函数。这意味着通过派生类对象或派生类指针调用该函数时，只会调用派生类中的函数，而不会调用基类中的函数。

代码演示：

class Person
{
public:
    void Print(int n = 6)
	{
		cout << n << endl;
	}

private:
	int _n;
};


class Member: public Person
{
public:
    //再次实现了Print函数，基类的Print函数就会隐藏
    void Print(int n = 0)
	{
		cout << n << endl;
	}
};



int main()
{
	Person per;
	//调用Print函数
	per.Print();

	Member mem;
	//调用Print函数
	mem.Print();

	return 0;
}

2.6.3 函数重载

函数重载（Function Overloading）是 C++ 中的一种多态形式，允许在一个作用域内定义多个同名函数，只要这些函数的参数列表不同。函数重载使得代码更具可读性和复用性，因为它允许使用同一个函数名称来执行类似的操作，但对不同类型或数量的参数进行不同的处理。

int Add(int n,int m)
{
	return n + m + 100;
}

// 接收浮点数
double Add(double n, double m)
{
	return n + m;
}

int main()
{
	int n = 0;
	int m = 1;
	cout << Add(n, m) << endl;

	return 0;
}

2.7 C++11 final 和override

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数
名字母次序写反而无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有
得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮
助用户检测是否重写。

final：修饰虚函数，表示该虚函数不能再被重写

class A
{
public:
	virtual void Print()
	{
		cout << "A : virtual void Print()" << endl;
	}
};

class B :public A
{
public:
	// B 的Print() 虚函数不能再被重写
	virtual void Print() final
	{
		cout << "B : virtual void Print()" << endl;
	}

};

override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class A
{
public:
	virtual void Print()
	{
		cout << "A : virtual void Print()" << endl;
	}
};

class B :public A
{
public:
	// 检查Print()虚函数是否完成了重写
	virtual void Print() override
	{
		cout << "B : virtual void Print()" << endl;
	}

};

3. 抽象类

3.1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

代码演示：

class A
{
public:
	//纯虚函数 : 在虚函数的后面加上 =0
	virtual void Print() = 0;
};

int main()
{
	// 抽象类定义不出对象，下列一行代码是错误的
	A a;

	//抽象类可以定义指针
	A* p;
	return 0;
}

同学们思考一下。下列代码中派生类B是不是抽象类？

class A
{
public:
	//纯虚函数 : 在虚函数的后面加上 =0
	virtual void Print() = 0;
};

class B : public A
{

};

答： B也是抽象类。因为B继承了类A，B相当于也包含了纯虚函数。但是，B重写纯虚函数后就不是抽象类了。

抽象类应用：

//抽象类
class A
{
public:
	//纯虚函数 : 在虚函数的后面加上 =0
	// 间接强制让派生类取重写
	virtual void Print() = 0;
};

class B : public A
{
public:
	//继承A，重写纯虚函数
	virtual void Print()
	{
		cout << "B : virtual void Print()" << endl;
	}
};

class C : public A
{
public:
	// 继承A，重写纯虚函数
	virtual void Print()
	{
		cout << "C : virtual void Print()" << endl;
	}
};

void Print(A* p)
{
	//指针指向谁就调用谁的Print函数
	p->Print();
}

int main()
{
	//创建一个B对象的指针
	Print(new B);

	//创建一个C对象的指针
	Print(new C);
}

3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实
现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成
多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

4. 虚函数表

虚函数表是一个数组，其中每个元素都是指向虚函数的指针。每个包含虚函数的类都会有一个对应的虚函数表，每个对象都有一个指向其类的虚函数表的指针（称为 vptr）

同学们看下列代码，猜一猜会打印出什么？

class A
{
public:
	virtual void Fun1()
	{
		cout << "Fun1()" << endl;
	}

	virtual void Fun2()
	{
		cout << "Fun2()" << endl;
	}

private:
	int _n;
};

int main()
{
	A a;
	// 打印 a占多少字节
	cout << sizeof(a) << endl;
	return 0;
}

在这里插入图片描述
同学们猜对了吗？
想知道是什么原因吗？

通过观察测试我们发现a对象是8bytes，除了_n成员，还多一个__vfptr放在对象的前面(注意有些
平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。那么派生类中这个表放了些什么呢？我们接着往下分析

打开监视，查看对象a的内容
在这里插入图片描述

重建一个继承关系的对象来观察：


// 针对上面的代码我们做出以下改造
// 1.A再增加一个虚函数Func2和一个普通函数Func3
// 2.我们增加一个派生类B去继承A
// 3.B中重写Func1
// 3.B中写一个自己的虚函数Fun4

class A
{
public:
	virtual void Fun1()
	{
		cout << "A :Fun1()" << endl;
	}

	virtual void Fun2()
	{
		cout << "A :Fun2()" << endl;
	}

	void Fun3()
	{
		cout << "A :Fun3()" << endl;
	}

private:
	int _n;
};

class B : public A
{
public:
	virtual void Fun1()
	{
		cout << "B :Fun1()" << endl;
	}

	// 自己的虚函数
	virtual void Fun4()
	{
		cout << "B :Fun4()" << endl;
	}

};

int main()
{
	A a;
	B b;

	return 0;
}

通过观察和测试，我们发现了以下几点问题：

派生类对象b中也有一个虚表指针，b对象由两部分构成，一部分是父类继承下来的成员，虚
表指针也就是存在部分的另一部分是自己的成员。
基类a对象和派生类b对象虚表是不一样的，这里我们发现Func1完成了重写，所以b的虚表
中存的是重写的B::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数
的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函
数，所以不会放进虚表。
虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生
类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己
新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？答：虚函数存在
虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意
虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是
他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的
呢？实际我们去验证一下会发现vs下是存在代码段的，Linux g++下大家自己去验证？

在这里插入图片描述