标签：静态编译 作用域 return use public 类对象 相同 函数 速度
问题引出：
如果子类定义了与父类中原型相同的函数会发生什么？（赋值兼容性原则遇上函数重写）
函数重写：
在子类中定义与父类中原型相同的函数，函数重写只发生在父类与子类之间。
class Parent
{
public:
void print()
{
cout<<"Parent:print() do..."<<endl;
}
};
class Child : public Parent
{
public:
void print()
{
cout<<"Child:print() do..."<<endl;
}
};
int main01()
{
run00();
Child child;
Parent *p = NULL;
p = &child;
child.print();
child.Parent::print();
system("pause");
return 0;
}
父类中被重写的函数依然会继承给子类
默认情况下子类中重写的函数将隐藏父类中的函数
通过作用域分辨符::可以访问到父类中被隐藏的函数
#include <iostream>
using namespace std;
class Parent
{
public:
void print()
{
cout<<"Parent:print() do..."<<endl;
}
};
class Child : public Parent
{
public:
void print()
{
cout<<"Child:print() do..."<<endl;
}
};
void howToPrint(Parent* p)
{
p->print();
}
void run00()
{
Child child;
Parent* pp = &child;
Parent& rp = child;
//child.print();
//通过指针
//pp->print();
//通过引用
//rp.print();
howToPrint(&child);
}
int main()
{
run00();
Child child;
Parent *p = NULL;
p = &child;
child.print();
child.Parent::print();
system("pause");
return 0;
}
1、在编译此函数的时，编译器不可能知道指针 p 究竟指向了什么。
2、编译器没有理由报错。
3、于是，编译器认为最安全的做法是编译到父类的print函数，因为父类和子类肯定都有相同的print函数。
英雄战机HeroFighter , AdvHeroFighter 分别和敌机EnemyFighter 战斗.
#include "iostream"
using namespace std;
class HeroFighter
{
public:
virtual int ackPower()
{
return 10;
}
};
class AdvHeroFighter : public HeroFighter
{
public:
virtual int ackPower()
{
return HeroFighter::ackPower()*2;
}
};
class enemyFighter
{
public:
int destoryPower()
{
return 15;
}
};
void objPK(HeroFighter *hf, enemyFighter *enemyF)
{
if (hf->ackPower() >enemyF->destoryPower())
{
printf("英雄打败敌人。。。胜利\n");
}
else
{
printf("英雄。。。牺牲\n");
}
}
void main()
{
HeroFighter hf;
enemyFighter ef;
objPK(&hf, &ef);
AdvHeroFighter advhf;
objPK(&advhf, &ef);
system("pause");
}
面向对象3大概念
封装
突破了C语言函数的概念
继承
代码复用
多态
多态可以使用未来的代码，例如80年代写了一个框架（对象唱戏的舞台）90年代写的代码可以调用该框架
多态是我们软件行业追寻的一个目标
//指针存在的意义：间接赋值
成立的3个条件
//1 定义两个变量。。。
//2 建立关联 。。。。
//3 *p
多态成立的三个条件
1、要有继承
2、要有函数重写。。。 虚函数（迟绑定技术）
没有指定虚函数, 那么它就只能访问到类型对应的函数
基类指针就只能访问到基类函数
子类指针就只能访问到子类函数
3、要有父类指针（或引用）指向子类对象（给对象搭建的舞台）
//多态是设计模式的基础，多态是框架的基础
参考
https://www.cnblogs.com/howo/p/8531449.html
多态的理论基础
静态联编和动态联编
1、联编是指一个程序模块、代码之间互相关联的过程。
2、静态联编（static binding），是程序的匹配、连接在编译阶段实现，也称为早期匹配。
重载函数使用静态联编。（不写virtual关键字）
3、动态联编是指程序联编推迟到运行时进行，所以又称为晚期联编（迟绑定）。（编译器看到virtual关键字对函数特殊处理）
switch 语句和 if 语句是动态联编的例子。
4、理论联系实际
|
1、C++与C相同，是静态编译型语言 2、在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象；所以编译器认为父类指针指向的是父类对象。 3、由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象 从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数。这种特性就是静态联编。因为基类指针，只能调用自己的函数，无法通过基类指针调用到子类的成员函数的（除非采用virtual，也就是迟绑定技术）。 |
虚函数
虚拟函数就是为了对“如果你以一个基础类指针指向一个衍生类对象，那么通过该指针，你只能访问基础类定义的成员函数”这条规则反其道而行之的设计。虚函数通过动态绑定技术实现了C++的运行时的多态性。让我们可以通过基类的指针或者引用调用派生类的方法。C++中还有一个多态性是编译时的多态，通过模版实现。
《Effective C++》条款 07 p44：
动态绑定的是怎么实现的？
1、为每个含义虚函数的类创建一个虚函数表VTable，存到常量区，依次存放虚函数的地址。对于每个派生类来说，如果没有重写基类的虚函数，那么派生类的虚函数表中的函数地址还是基类的那个虚函数地址。
2、为每个含有虚函数的对象创建一个指向VTable的指针VPtr，所以说同类对象的VPtr是一样的。
3、当基类指针指向派生类时，放生了强制转换，基类的指针指向了派生类的VPtr，这样当pBase->func()时，就可以调用派生类的func()了。
4、没有虚函数的类也就没有VTable表了，或者这个表为空。这样基类指针自然调用不到派生类的函数了。
|
C++中多态的实现原理 当类中声明虚函数时，编译器会在类中生成一个虚函数表 虚函数表是一个存储类成员函数指针的数据结构 虚函数表是由编译器自动生成与维护的 virtual成员函数会被编译器放入虚函数表中 存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针) C++编译器为每一个类定义对象的时候，它会在每一个类后面布局一个vptr指针。Vptr指针会为每一个类的虚函数生成一个虚函数表，并指向这个表。当发挥多态的时候（有虚函数调用的时候）编译器会根据传入的vptr找到虚函数表，实现多态。
|
|
说明1： 通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。 说明2： 出于效率考虑，没有必要将所有成员函数都声明为虚函数 |
|
说明3 ：C++编译器，执行HowToPrint函数，不需要区分是子类对象还是父类对象
|
多态相关面试题
面试题1：请谈谈你对多态的理解
|
多态的实现效果 多态：同样的调用语句有多种不同的表现形态； 多态实现的三个条件 有继承、有virtual重写、有父类指针（引用）指向子类对象。 多态的C++实现
virtual关键字，告诉编译器这个函数要支持多态；不是根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用 动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。 多态的重要意义 设计模式的基础 是框架的基石。 实现多态的理论基础 函数指针做函数参数
C函数指针是C++至高无上的荣耀。C函数指针一般有两种用法（正、反）。 多态原理探究 与面试官展开讨论 |
面试题2：谈谈C++编译器是如何实现多态
c++编译器多态实现原理
面试题3：谈谈你对重写，重载理解
函数重载
必须在同一个类中进行
子类无法重载父类的函数，父类同名函数将被名称覆盖
重载是在编译期间根据参数类型和个数决定函数调用
函数重写
必须发生于父类与子类之间
并且父类与子类中的函数必须有完全相同的原型
使用virtual声明之后能够产生多态(如果不使用virtual，那叫重定义)
多态是在运行期间根据具体对象的类型决定函数调用
#include <cstdlib>
#include <iostream>
using namespace std;
class Parent01
{
public:
Parent01()
{
cout<<"Parent01:printf()..do"<<endl;
}
public:
virtual void func()
{
cout<<"Parent01:void func()"<<endl;
}
virtual 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;
}
};
class Child01 : public Parent01
{
public:
//此处2个参数，和子类func函数是什么关系
void func(int i, int j)
{
cout<<"Child:void func(int i, int j)"<<" "<<i + j<<endl;
}
//此处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
c.Parent01::func();
c.func(1, 2);
run01(&p);
run01(&c);
system("pause");
return 0;
}
面试题4：是否可类的每个成员函数都声明为虚函数，为什么。
可以但不建议这样做，因为它会有多态虚拟函数，降低速度。
面试题5：构造函数中调用虚函数能实现多态吗？为什么？
c++编译器多态实现原理
面试题6：虚函数表指针（VPTR）被编译器初始化的过程，你是如何理解的？
c++编译器多态实现原理
面试题7：父类的构造函数中调用虚函数，能发生多态吗？
c++编译器多态实现原理
面试题8：为什么要定义虚析构函数？
在什么情况下应当声明虚函数
标签：静态编译 作用域 return use public 类对象 相同 函数 速度
原文地址：https://www.cnblogs.com/juanjuanduang/p/10847635.html
