继承，多态(静态多态，动态多态)

上一篇关于虚函数指针的原理总结完，总感觉还没学透，还有一些问题

上一篇看这里：虚函数原理和多态(超详细)-CSDN博客

1、问题一：既然基类指针指向派生类对象，访问虚函数的时候访问的是派生类的，那为什么不能访问派生类的非虚函数

看下面代码：

#include<iostream>

using std::cout;
using std::endl;

class Person {
public:
	virtual void func1()
	{
		cout << "Person::func1" << endl;
	}


private:
	int _a;
};

class Student : public Person {
public:
	virtual void func1()
	{
		cout << "Student::func1" << endl;
	}

	void print() {}
private:
	int _b;
};

int main()
{
	Student s1;
	Person* p1 = &s1;
	p1->func1();
	
	return 0;
}

执行结果：

然后用p1访问print(),就会报错

这里可以说基类指针只能访问派生类中和基类相同的部分，所以访问不到派生类中的print函数，但是我们知道，成员函数的是通过this指针来访问的，既然p1指向的this指针已经赋值为派生类的了(其实这里只是派生类的__vfptr赋值给基类的__vfptr)，为什么不能访问派生类中的非虚函数，而能访问虚函数

看下面代码的单步调试

class Person {
public:
	virtual void func1()
	{
		cout << "Person::func1" << endl;
	}

	void print_base() {}
	void func2()
	{
		print_base();
	}
private:
	int _a;
};

class Student : public Person {
public:
	virtual void func1()
	{
		cout << "Student::func1" << endl;
	}

	void print() {}
private:
	int _b;
};

int main()
{
	Student s1;
	Person* p1 = &s1;
	p1->func2();
	
	return 0;
}

func2里面的this指针已经是指向Student对象的地址，但是这个this指针仍然是Person*的，所以其访问范围只是Person类那一部分，不能访问Student类除Person类的其他部分 (这么一个小点困扰我半天，真是被绕晕了)

所以不能访问派生类中的非虚函数函数就可以理解

而这个时候如果访问虚函数的话，肯定是访问指向Student对象的this指针里面的虚函数，所以访问虚函数的时候执行结果是Student::func1

2、什么是静态多态，什么是动态多态

先说概念:

静态多态：
编译时多态是静态多态，在编译时就可以确定使用的接口。 包括函数重载，运算符重载，模板等

动态多态：

运行时多态是动态多态，具体引用的接口在运行时才能确定，虚函数

这个上一篇就提到了

那么来看看下面这个代码：

class A
{
public:
    void func(){ std::cout << "A::func()" << endl; }
};

class B : public A
{
public:
    void func(){ std::cout << "B::func()"<< endl; }
};

class C : public A
{
public:
    void func(){ std::cout << "C::func()" << endl; }
};

int main()
{
	C * pnull = nullptr;
	pnull->func();
}

能执行成功吗?执行结果是啥？

this指针指向为地址0的地方，但是能执行成功

为什么呢？

那就需要引入下面这些概念了

• 静态类型：对象在声明时采用的类型，在编译期既已确定；
• 动态类型：通常是指一个指针或引用目前所指对象的类型，是在运行期决定的；
• 静态绑定：绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发生在编译期；
• 动态绑定：绑定的是动态类型，所对应的函数或属性依赖于对象的动态类型，发生在运行期；

从上面的概念可以看出非虚函数一般都是静态绑定，而虚函数都是动态绑定（这样才能实现动态多态）

所以用上面的概念来说明下面的声明与定义

C* pc = new C(); //pc的静态类型是它声明的类型C*，动态类型也是C*；

B* pb = new B(); //pb的静态类型和动态类型也都是B*；

A* pa = pc;      //pa的静态类型是它声明的类型A*，动态类型是pa所指向的对象pc的类型C*；

pa = pb;         //pa的动态类型可以更改，现在它的动态类型是B*，但其静态类型仍是声明时候的A*；

C *pnull = NULL; //pnull的静态类型是它声明的类型C*,没有动态类型，因为它指向了NULL；

继续看下面代码的执行：

int main()
{
	C* pc = new C(); //pc的静态类型是它声明的类型C*，动态类型也是C*；
	B* pb = new B(); //pb的静态类型和动态类型也都是B*；
	A* pa = pc;      //pa的静态类型是它声明的类型A*，动态类型是pa所指向的对象pc的类型C*；
	pa = pb;         //pa的动态类型可以更改，现在它的动态类型是B*，但其静态类型仍是声明时候的A*；
	C *pnull = NULL; //pnull的静态类型是它声明的类型C*,没有动态类型，因为它指向了NULL；

	pa->func();      //A::func() pa的静态类型永远都是A*，不管其指向的是哪个子类，都是直接调用A::func()；
	pc->func();      //C::func() pc的动、静态类型都是C*，因此调用C::func()；
	pnull->func();	 //C::func() 不用奇怪为什么空指针也可以调用函数，因为这在编译期就确定了，和指针空不空没关系；
}

看一下pa的this指针，仍然是A*,其他的this指针也是他们的静态类型

如果注释掉类C中的func函数定义，其他不变，即

class C : public A
{
};

pa->func();      //A::func() 理由同上；
pc->func();      //A::func() pc在类C中找不到func的定义，因此到其基类中寻找；
pnull->func();   //A::func() 原因也解释过了；

如果为A中的void func()函数添加virtual特性，其他不变，即

class A
{
public:
    virtual void func(){ std::cout << "A::func()\n"; }
};

pa->func();      //B::func() 因为有了virtual虚函数特性，pa的动态类型指向B*，因此先在B中查找，找到后直接调用；
pc->func();      //C::func() pc的动、静态类型都是C*，因此也是先在C中查找；
pnull->func();   //空指针异常，因为是func是virtual函数，因此对func的调用只能等到运行期才能确定，访问pnull时然后才发现pnull是空指针；

分析：
在上面的例子中，

1. 如果基类A中的func不是virtual函数，那么不论pa、pb、pc指向哪个子类对象，对func的调用都是在定义pa、pb、pc时的静态类型决定，早已在编译期确定了。

同样的空指针也能够直接调用no-virtual函数而不报错（这也说明一定要做空指针检查啊！）；

2. 如果func是虚函数，那所有的调用都要等到运行时根据其指向对象的类型才能确定，比起静态绑定自然是要有性能损失的，但是却能实现多态特性；

这里的代码都是指针分析，也适用于引用的使用的情况

总结一下静态绑定和动态绑定的区别：
1. 静态绑定发生在编译期，动态绑定发生在运行期；

2. 对象的动态类型可以更改，但是静态类型无法更改；

3. 要想实现动态多态，必须使用动态绑定；

4. 在继承体系中只有虚函数使用的是动态绑定，其他的全部是静态绑定；

所以结论：

        实现动态多态就是通过虚函数指针，定义了虚函数的类都有一个虚函数指针，虚函数指针指向虚表，虚表存的是虚函数的入口地址，当基类指针指向派生类对象时，只是把派生类的__vfptr的值赋值给基类__vfptr（也就是this->__vfptr,this是基类* （Person*）类型），也就是基类的指针这时指向派生类的虚表，至于派生类的虚表里是哪种情况，参照上一篇（虚函数原理和多态(超详细)-CSDN博客），没有虚函数指针，就都是编译时期确定，那就是静态多态的事了，和什么虚函数这些就无关了

到这里，基本上都串起来了，虚函数，虚函数原理，this指针的变化，动态多态怎么实现，大概就这些，至于编译期到底干了啥，从而实现上面这些情况，以后研究吧，头疼(要长脑子了)

参考：

C++中的静态绑定和动态绑定 - lizhenghn - 博客园 (cnblogs.com)

再加上一个练习熟悉：

多基派生的梳理和练习-CSDN博客