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;
}