C++_多态

多态：
同样的一句话，可表示不同的意思。
面向对象三大特征：
封装
突破了C语言函数的概念。。

继承
代码复用 。。。。我复用原来写好的代码。。。

多态
多态可以使用未来。。。。。80年代写了一个框架。。。。。。90人写的代码
多态的条件：
1 要有继承。
2 要有函数的重写。（父和子都有同一个函数）
3 用父类指针指向子类对象。
下面是一个多态的例子：
例子中，父类是一个战机，子类是升级过后的战机，另一个类是敌机。

#include <iostream>
using namespace std;
class HeroFighter
{
public:
	virtual int power()
	{
		return 10;
	}
private:
};
class AnemyFighter
{
public:
	int attack()
	{
		return 15;
	}
};
class AdvHeroFighter :public HeroFighter
{
public:
	int power()
	{
		return 20;
	}
};
class AdvAdvHeroFighter :public AdvHeroFighter
{
public:
	int power()
	{
		return 30;
	}
};
//多态的威力:
//这是多态的方式，意思是说，给第一个参数是父类的对象，没有升级的，则执行没有升级过的power函数，如果是升级过的，则执行升级过的power函数
//Anemy。。。也是如此。
void PlayObj(HeroFighter *hf, AnemyFighter *af)
{
	if (hf->power() > af->attack())
	{
		cout << "hf win" << endl;
	}
	else
	{
		cout << "hf lose" << endl;
	}
}
int main()
{
	HeroFighter hf;
	AdvHeroFighter Advhf;
	AnemyFighter ef;
	AdvAdvHeroFighter AdvAdvhf;
	PlayObj(&hf, &ef);
	PlayObj(&Advhf, &ef);
	PlayObj(&AdvAdvhf, &ef);
	system("pause");
	return 1;
}

请比较下面的代码，下面的代码不是多态实现。

int main01()
{

	HeroFighter hf;
	AdvHeroFighter Advhf;
	AnemyFighter ef;
	//让战机PK
	if (hf.power() > ef.attack())
	{
		cout << "hf win" << endl;
	}
	else
	{
		cout << "hf lose" << endl;
	}

	if (Advhf.power() > ef.attack())
	{
		cout << "Adv object win" << endl;
	}
	else
	{
		cout << "Adv object lose" << endl;
	}
	system("pause");
	return 1;
}

虚析构函的使用

#define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

class A {
public:
	A()
	{
		p = new char[20];
		strcpy(p, "objk");
	}
	virtual ~A() {
		delete[] p;
		cout << "~A()" << endl;
	}
private:
	char *p;

};

class B:public A
{
public:
	B()
	{
		p = new char[20];
		strcpy(p, "objkbbbbb");
	}
	~B() {
		delete[] p;
		cout << "~B()" << endl;
	}
private:
	char *p;

};
class C:public B {
public:
	C()
	{
		p = new char[20];
		strcpy(p, "objkccccc");
	}
	~C() {
		delete[] p;
		cout << "~C()" << endl;
	}
private:
	char *p;

};

//搭建舞台
//想通过父类指针，释放所有的子对象的析构函数。
//这种情况下 就用到了虚析构函数。
void howtodelete(A *base)
{
	delete base;
}

int main()
{

	C *myC = new C;
	cout << "C" << sizeof(C) << endl;
	howtodelete(myC);
	system("pause");
	return 1;
}

在主函数中不用deletemyC对象，能直接调用A B类中的析构函数。

多态原理探究

理论知识：
当类中声明虚函数时，编译器会在类中生成一个虚函数表
虚函数表是一个存储类成员函数指针的数据结构
虚函数表是由编译器自动生成与维护的
virtual成员函数会被编译器放入虚函数表中
当存在虚函数时，每个对象中都有一个指向虚函数表的指针（C++编译器给父类对象、子类对象提前布局vptr指针；当进行howToPrint(Parent base)函数是，C++编译器不需要区分子类对象或者父类对象，只需要再base指针中，找vptr指针即可。）
VPTR一般作为类对象的第一个成员
C++中多态的实现原理
当类中声明虚函数时，编译器会在类中生成一个虚函数表
虚函数表是一个存储类成员函数指针的数据结构
虚函数表是由编译器自动生成与维护的
virtual成员函数会被编译器放入虚函数表中
存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针)



说明1：
通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上*，虚函数的效率要低很多。**
说明2：
出于效率考虑，没有必要将所有成员函数都声明为虚函数

如何证明vptr指针的存在

#include <iostream>
using namespace std;

class A
{
public:
	void printf()
	{
		cout<<"aaa"<<endl;
	}
protected:
private:
	int a;
};

class B
{
public:
	virtual void printf()
	{
		cout<<"aaa"<<endl;
	}
protected:
private:
	int a;
};

void main()
{
	//加上virtual关键字 c++编译器会增加一个指向虚函数表的指针 。。。
	printf("sizeof(a):%d, sizeof(b):%d \n", sizeof(A), sizeof(B));
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

类B加了virtual关键字的函数，输出的长度是8，而A输出的是4。

下面是几个多态的面试题

**

1. 面试题4：是否可类的每个成员函数都声明为虚函数，为什么。

**
说明1：
通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。
说明2：
出于效率考虑，没有必要将所有成员函数都声明为虚函数
说明3 ：C++编译器，执行HowToPrint函数，不需要区分是子类对象还是父类对象

2.## 面试题1：请谈谈你对多态的理解

一个函数，在子类中穿梭时，表现出不同的形态，叫做多态。
从几个方面说明：
多态的实现效果
多态：同样的调用语句有多种不同的表现形态；
多态实现的三个条件
有继承、有virtual重写、有父类指针（引用）指向子类对象。
多态的C++实现
virtual关键字，告诉编译器这个函数要支持多态；不是根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用
多态的理论基础
动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。
多态的重要意义
设计模式的基础 是框架的基石。
实现多态的理论基础
函数指针做函数参数
C函数指针是C++至高无上的荣耀。C函数指针一般有两种用法（正、反）。
多态原理探究
与面试官展开讨论
C++编译器提前布局了一个vptr指针，通过指针找到虚函数列表，找到函数的入口地址，动态的。。。

面试题2：谈谈C++编译器是如何实现多态

C++中多态的实现原理
当类中声明虚函数时，编译器会在类中生成一个虚函数表
虚函数表是一个存储类成员函数指针的数据结构
虚函数表是由编译器自动生成与维护的
virtual成员函数会被编译器放入虚函数表中
存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针)

面试：构造函数中能调用虚函数，实现多态吗

代码：

#include <iostream>
using namespace std;

//构造函数中调用虚函数能发生多态吗?

class Parent
{
public:
	Parent(int a=0)
	{
		this->a = a;
		print();
	}

	virtual void print()  
	{
		cout<<"我是爹"<<endl;
	}
	
private:
	int a;
};

class Child : public Parent
{
public:
	Child(int a = 0, int b=0):Parent(a)
	{
		this->b = b;
		print();
	}

	virtual void print()
	{
		cout<<"我是儿子"<<endl;
	}
private:
	int b;
};

void HowToPlay(Parent *base)
{
	base->print(); //有多态发生  //2 动手脚  
	
}

void main()
{

	Child  c1; //定义一个子类对象 ,在这个过程中,在父类构造函数中调用虚函数print 能发生多态吗?
	//c1.print();
	
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

不能，原理如下图。

面试题8：为什么要定义虚析构函数？

构造函数不能是虚函数。建立一个派生类对象时，必须从类层次的根开始，沿着继承路径逐个调用基类的构造函数
 析构函数可以是虚的。虚析构函数用于指引 delete 运算符正确析构动态对象。

父类指针与子类指针的步长
#include
using namespace std;

//结论:
//多态是用父类指针指向子类对象 和 父类步长++,是两个不同的概念

class Parent
{
public:
	Parent(int a=0)
	{
		this->a = a;
	}

	virtual void print()  
	{
		cout<<"我是爹"<<endl;
	}

private:
	int a;
};


//成功 ,一次偶然的成功 ,必然的失败更可怕
class Child : public Parent
{
public:
	/*
	Child(int a = 0, int b=0):Parent(a)
	{
		this->b = b;
		print();
	}
	*/
	
	Child(int b = 0):Parent(0)
	{
		//this->b = b;
	}
	

	virtual void print()
	{
		cout<<"我是儿子"<<endl;
	}
private:
	//int b;
};

void HowToPlay(Parent *base)
{
	base->print(); //有多态发生  //2 动手脚  

}

void main411()
{

	Child  c1; //定义一个子类对象 ,在这个过程中,在父类构造函数中调用虚函数print 能发生多态吗?
	//c1.print();

	Parent *pP = NULL;
	Child  *pC = NULL;

	Child  array[] = {Child(1), Child(2), Child(3)};
	pP = array;
	pC = array;

	pP->print();
	pC->print(); //多态发生  ，第一次正常输出。


	pP++;
	pC++;
	pP->print();
	pC->print(); //多态发生,第二次发生了内存错误，本质原因如下图。


	pP++;
	pC++;
	pP->print();
	pC->print(); //多态发生


	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

发生错误：
pP++;
pC++;
pP->print();
pC->print(); //多态发生,第二次发生了内存错误，本质原因如下图。

错误原因如下：

第二次pC++时，指向了数组的下一个地址，而父类指针第二次指向的不是下一个地址的开始。
本质原因就是，父类和子类的内存大小不一样。