c++-多态的学习

多态的基本介绍

多态基础
- 面向对象新求
- C++编译器提供的多态解决方案
- 多态意义、多态成立的是三个条件
- 多态理论基础
多态面试题强化
- 多态的理解
- C++编译器如何实现多态
- 重载重写重定义
- 虚析构函数
- 可否为每个类的普通成员函数定义为虚函数
- 构造函数中调用虚函数，能实现多态吗？
- 虚函数表指针vptr指针分步初始化
- 父类指针和子类指针步长不一样和父类指针指向子类对象两个不同的概念
多态原理探究
- 总结记忆1：C++编译器提前布局，在类对象中增加vptr指针、虚函数入口地址存虚函数表
- 总结记忆2： C++编译器并不是区分子类对象和父类对象，而是根据对象指针、找vptr指针，再找虚函数入口，实现迟绑定，支持了多态
多态发生的三个必要条件：
- 要有继承。
- 要有虚函数重写。
- 父类指针或引用指向子类对象。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>

using namespace std;


//岳不群
class Yuebuqun
{
public:
	Yuebuqun( string kongfu)
	{
		this->kongfu = kongfu;
	}

	virtual  void fight() //标识修饰一个成员方法是一个虚函数。
	{
		cout << "岳不群" << "使出了" << kongfu << "打人" << endl;
	}

	void print()
	{

	}

	string kongfu;
};

//林平之 继承了 岳不群
class Linpingzhi :public Yuebuqun
{
public:
	Linpingzhi(string kongfu) :Yuebuqun(kongfu)
	{

	}

	//如果说父类中有一个虚函数是fight（ ）， 子类如果去重写这个虚函数。
	void fight()
	{
		cout << "林平之" << "使出了" << kongfu << "打人" << endl;
	}

	void print()
	{

	}
};

class Linghuchong :public Yuebuqun
{
public:
	Linghuchong(string kongfu) :Yuebuqun(kongfu)
	{

	}

	void  fight()
	{
		cout << "令狐冲 " << "使用了" << kongfu << endl;
	}
};

//在全局提供一个打斗的方法
void fightPeople(Yuebuqun *hero)//Yuebuqun *hero = xiaopp;  Yuebuqun *hero = xiaoyy;
{
	cout << "调用打人的方法" << endl;
	hero->fight();//希望传递进来的如果是子类，调用子类的fight
			      //如果传递进来的是父类， 调用父类的fight
					//这种行为就是 多态行为。
}



int main(void)
{
	Yuebuqun *xiaoyy = new Yuebuqun("葵花宝典");

	//xiaoyy->fight();



	Linpingzhi *xiaopp = new Linpingzhi("僻邪剑谱");
	//xiaopp->fight();

	Linghuchong *xiaoll = new Linghuchong("独孤九剑");

	 
	fightPeople(xiaoyy);
	fightPeople(xiaopp);
	fightPeople(xiaoll);
	//编译器默认做了一个安全的处理。 编译认为 不管传递时子类对象还是父类对象，
	//如果统一执行父类d方法 那么是一定可以被成功执行。

	delete xiaoyy;
	delete xiaopp;
	delete xiaoll;

	return 0;
}

多态案例及其意义

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>


using namespace std;

//英雄类
//1999
class Hero
{
public:
	virtual int getAd() {
		return 10;
	}
};

//1999
class AdvHero :public Hero
{
public:
	virtual int getAd()
	{
		return 1001;
	}
};

//怪兽类
//1999
class Monster
{
public:
	int getAd() {
		return 1000;
	}
};


//战斗方法
//1999 //写的架构函数，可以调用未来。
void playerFight(Hero *hp, Monster *mp)
{
	//多态对于编译器来讲的，也是一个动态联编，也是一个迟邦定。
	if (hp->getAd() > mp->getAd()) { //hp->getAd 发生了多态
		cout << "英雄胜利， 怪兽被打死" << endl;
	}
	else {
		cout << "英雄挂了，怪兽赢了" << endl;
	}
}

//2020年
class BugHero :public Hero
{
public:
	virtual int getAd()
	{
		cout << "调用了bugHero的方法" << endl;
		return 66666;
	}
};

int main(void)
{
	Hero h;

	Monster m;

	playerFight(&h, &m);


	AdvHero advH;

	playerFight(&advH, &m);


	BugHero bH;

	playerFight(&bH, &m);

	int a = 10;
	int b = 20;

	cout << a << endl;

	if (a > 10) { //迟邦定
		cout << "a>10" << endl;
	}
	else {
		cout << "a < 10" << endl;
	}


	return 0;
}