C++多态基础以及编译器多态实现原理

1、 多态基础

多态的实现效果 多态：同样的调用语句有多种不同的表现形态； 多态实现的三个条件 有继承、有virtual重写、有父类指针（引用）指向子类对象。 多态的C++实现 virtual关键字，告诉编译器这个函数要支持多态；不要根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用 多态的理论基础 动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。 多态的重要意义 设计模式的基础。 实现多态的理论基础 函数指针做函数参数 铁律10： C函数指针是C++至高无上的荣耀。C函数指针一般有两种用法（正、反）。

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

0

说明1：

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

说明2：

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

多态原理探究（证明VPTR指针的存在）

#include<iostream>
class AA
{
public:
virtual void print()//C++编译器提前布局了这里多了一个virt指针
{
std::cout << "dddd" << std::endl;
}
protected:
private:
int b;
};
void main()
{
std::cout << "AA=" << sizeof(AA) << std::endl;
system("pause");

}

结果输出:8 (int b占4个字节+vptr指针4个字节)证明vptr指针存在

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

1）对象中的VPTR指针什么时候被初始化？ 对象在创建的时,由编译器对VPTR指针进行初始化 只有当对象的构造完全结束后VPTR的指向才最终确定 父类对象的VPTR指向父类虚函数表 子类对象的VPTR指向子类虚函数表

子类的vptr指针是分布赋值的

#include "iostream"
using namespace std;

//现象
//实现方法3
//多态的原理
//

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

void printAbc()
{
printf("父类abc");
}
//第一个动手脚的地方 编译器应该对这个虚函数特殊处理。。。。
virtual void print()
{
cout<<"父类函数"<<endl;
}
protected:
private:
int a;
};

class Child : public Parent
{
public:
Child(int b = 0)
{
this->b = b;
}
void print()
{
cout<<"子类函数"<<endl;
}
protected:
private:
int b ;
};

void main()
{

//Parent p1; //在这个地方，，编译器已经提前布局。。。。。给函数有虚函数表的对象，提前加了vptr指针。。
Child c1;

system("pause");
}

为什么要定义虚析构函数

在父类中声明虚析构函数的原因

通过父类指针，把所有的子类析构函数都执行一遍。。。
在父类的构造函数里面，调用虚函数，不会产生多态。。
言外之意：不会调用子类的虚函数。。。。

#include "iostream"
using namespace std;

//现象
//实现方法3
//多态的原理
//

class Parent
{
public:
//在父类的构造函数里面，调用虚函数，不会产生多态。。
//言外之意：不会调用子类的虚函数。。。。
Parent(int a = 0)
{
//print(); //
this->a = a;
}
virtual ~Parent()
{
cout<<"调用父类虚析构函数"<<endl;
}

void printAbc()
{
printf("父类abc");
}
//第一个动手脚的地方 编译器应该对这个虚函数特殊处理。。。。
virtual void print()
{
cout<<"父类函数"<<endl;
}
protected:
private:
int a;
};

class Child : public Parent
{
public:
Child(int b = 0)
{
this->b = b;
}
~Child()
{
cout<<"调用子类的虚析构函数"<<endl;
}
virtual void print()
{
cout<<"子类函数"<<endl;
}
protected:
private:
int b ;
};

//在父类中声明虚析构函数的原因
//通过父类指针，把所有的子类析构函数都执行一遍。。。
//
void howtoDel(Parent *pbase)
{
delete pbase;
}

void mainobj()
{
Parent *p1 = new Parent();
p1->print();
delete p1;
}

void main()
{
Child *pc1 = new Child();

howtoDel(pc1);

//mainobj();

system("pause");
}

基类和子类对象指针++混搭风

(偶然成功比必然失败更可怕)

不要轻易的通过父类指针p++来执行函数操作(很容易找不到函数入口点)

问题的本质,子类对象和父类指针步长,可能不一样

#include<iostream>

class Parent01
{
protected:
int i;
int j;
public:
virtual void f()//普通虚函数
{
std::cout << "Parent01::f" << std::endl;
}
};
class Child01 :public Parent01
{
public:
//int k;这里不加,子类对象大小与父类对象大小相等
public:
Child01(int i, int j)
{
std::cout << "Child01....do" << std::endl;
}
virtual void f()
{
std::cout << "Child01::f()" << std::endl;
}
};
void howToF(Parent01 *pBase)
{
pBase->f();
}
//偶然成功比必然失败更可怕
int main()
{
int i = 0;
Parent01*p = NULL;
Child01*c = NULL;
//可以使用赋值兼容性原则,适用于howToF
//不要轻易的通过父类指针p++来执行函数操作(很容易找不到入口点),
//问题的本质,子类对象和父类指针步长,可能不一样
Child01 ca[3] = { Child01(1, 2), Child01(3, 4), Child01(5, 6) };
p = ca;//第一个子类对象赋值给p,p是基类指针
c = ca;

p->f();//多态发生
c->f();
p++;
//c++;
p->f();
c->f();
for (int i = 0; i < 3; i++)
{
howToF(&(ca[i]));
}
system("pause");
return 0;

}

没有找到入口点,父类指针非法访问

纯虚函数接口类(抽象类)

virtual int showarea() = 0;//纯虚函数

通过抽象类,定义一套接口,让别人使用

框架就可以在不做任何改变的情况下,调用后来人写的抽象类的子类

抽象类无法直接创建对象

建立一个抽象类指针合法

#include<iostream>
//抽象类
class figure
{
public:
virtual int showarea() = 0;//纯虚函数

};
class Tri :public figure
{
public:
Tri(int a = 0, int b = 0)
{
this->a = a;
this->b = b;
}
virtual int showarea()
{
std::cout << "三角形面积=" << a*b / 2 << std::endl;
return 0;
}
private:
int a;
int b;
};
class square :public figure
{
public:
square(int a = 0, int b = 0)
{
this->a = a;
this->b = b;
}
virtual int showarea()
{
std::cout << "四边形面积=" << a*b << std::endl;
return a*b;
}
private:
int a;
int b;

};
//通过抽象类,定义一套接口,让别人使用
//框架就可以在不做任何改变的情况下,调用后来人写的抽象类的子类
void printS(figure *pbase)//这就是我写的框架(多态实现)
{
pbase->showarea();
}
void mai8n()//土方法调用
{
//figure f;抽象类无法直接创建对象
figure *p = NULL;//建立一个抽象类指针合法

Tri tri(10,2);
tri.showarea();
square sq(3, 4);
sq.showarea();
system("pause");
}
void mai111111n()
{
Tri tri(10, 2);
square sq(3, 4);
printS(&tri);
printS(&sq);
system("pause");
}

//抽象类应用举例

#include "iostream"
using namespace std;

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//继承接口1,接口2
{
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()
{
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");
}