1. 重写 PK 重载理解

1.1 函数重载

必须在同一个类中进行

子类无法重载父类的函数，父类同名函数将被名称覆盖

重载是在编译期间根据参数类型和个数决定函数调用

1.2 函数重写

必须发生于父类与子类之间

并且父类与子类中的函数必须有完全相同的原型

使用virtual声明之后能够产生多态(如果不使用virtual，那叫重定义)

多态是在运行期间根据具体对象的类型决定函数调用

#include <cstdlib>
#include <iostream>

using namespace std;

//重载只放在在一个类里面 ，在编译期间就确定
class Parent01
{
public:
	Parent01()
	{
		cout << "Parent01:printf()..do" << endl;
	}
public:
	void aaaaa()
	{
		;
	}
	void func()
	{
		cout << "Parent01:void func()" << endl;
	}

	void func(int i)
	{
		cout << "Parent:void func(int i)" << endl;
	}

	virtual void func(int i, int j)
	{
		cout << "Parent:void func(int i, int j)" << endl;
	}
};

//重写 父子类之间，函数三要素（函数名、函数参数、函数返回类型）完全一样
//重写又分为两种
//如果父类中有virtual关键字，这种父子之间的关系叫做虚函数重写，这种情况下发生多态 （动态链编 迟绑定）
//如果父类中没有virtual关键字，这种父子之间的关系 重定义  （静态链编）
class Child01 : public Parent01
{

public:

	//此处2个参数，和父类func函数是什么关系 【多态】
	void func(int i, int j)
	{
		cout << "Child:void func(int i, int j)" << " " << i + j << endl;
	}

	//我想在子类中重载父类的func函数  ====》c.Parent01::func();
	//此处3个参数的，和父类func函数是什么关系   【只是函数名相同】
	void func(int i, int j, int k)
	{
		cout << "Child:void func(int i, int j, int k)" << " " << i + j + k << endl;
	}
};

void run01(Parent01* p)
{
	p->func(1, 2);
}

int main()
{
	Parent01 p;

	p.func();
	p.func(1);
	p.func(1, 2);

	Child01 c;
	//c.func(); //注意1:error C2661: “Child01::func”: 没有重载函数接受 0 个参数
	c.Parent01::func();
	c.aaaaa();
	//c.func(1, 2);

	run01(&p);
	run01(&c);

	system("pause");

	return 0;
}

//问题1：child对象继承父类对象的func，请问这句话能运行吗？why
//c.func(); 

//1子类里面的func无法重载父类里面的func
//2当父类和子类有相同的函数名、变量名出现，发生名称覆盖
//3//c.Parent::func();
//问题2 子类的两个func和父类里的三个func函数是什么关系？

2.请你谈谈你对多态的理解？

多态的实现效果

多态：同样的调用语句有多种不同的表现形态；

多态实现的三个条件

有继承、有virtual重写、有父类指针（引用）指向子类对象。

多态的C++实现

virtual关键字，告诉编译器这个函数要支持多态；不要根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用

多态的理论基础

动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。

多态的重要意义

设计模式的基础。

实现多态的理论基础

函数指针做函数参数

3.多态原理的实现？

当类中声明虚函数时，编译器会在类中生成一个虚函数表

虚函数表是一个存储类成员函数指针的数据结构

虚函数表是由编译器自动生成与维护的

virtual成员函数会被编译器放入虚函数表中

存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针)

说明1：

通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。

说明2：

出于效率考虑，没有必要将所有成员函数都声明为虚函数

4.构造函数中能调用虚函数，实现多态吗？why？

构造函数中调用多态函数,不能实现多态。

对象在创建的时,由编译器对VPTR指针进行初始化

只有当对象的构造完全结束后VPTR的指向才最终确定

父类对象的VPTR指向父类虚函数表

子类对象的VPTR指向子类虚函数表

1.低昂指向父类的构造函数的时候，c++编译器会初始化子类的vptr指针，让vptr指针指向父类的虚函数表。如果在父类的构造函数里面调用虚函数，此时调用的是父类的函数。这个时候并没有产生多态。

2.当父类的构造函数执行完毕以后，再执行子类的构造函数，这个时候，让vptr指针真正的指向子类的虚函数表。此时产生多态。

5.多继承接口

C++中没有接口的概念

C++中可以使用纯虚函数实现接口

接口类中只有函数原型定义，没有任何数据的定义。

#include "iostream"
using namespace std;

/*
C++中没有接口的概念
C++中可以使用纯虚函数实现接口
接口类中只有函数原型定义，没有任何数据的定义。
*/

class Interface1
{
public:
	virtual void print() = 0;
	virtual int add(int i, int j) = 0;
};

class Interface2
{
public:
	virtual int add(int i, int j) = 0;
	virtual int minus(int i, int j) = 0;
};

class parent
{
public:
	int i;
};

class Child : public parent, public Interface1, public Interface2
{
public:
	void print()
	{
		cout << "Child::print" << endl;
	}

	int add(int i, int j)
	{
		return i + j;
	}

	int minus(int i, int j)
	{
		return i - j;
	}
};

int main(int argc, char *argv[])
{
	Child c;

	c.print();

	cout << c.add(3, 5) << endl;
	cout << c.minus(4, 6) << endl;

	Interface1* i1 = &c;
	Interface2* i2 = &c;

	cout << i1->add(7, 8) << endl;
	cout << i2->add(7, 8) << endl;
	system("pause");
}