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

最新推荐文章于 2024-08-01 16:59:17 发布

隐无影

最新推荐文章于 2024-08-01 16:59:17 发布

阅读量553

点赞数

本文链接：https://blog.csdn.net/u011391093/article/details/42420841

版权

1、多态基础

多态的实现效果

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

多态实现的三个条件

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

多态的C++实现

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

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

多态的重要意义

设计模式的基础。

实现多态的理论基础

函数指针做函数参数

铁律10： C函数指针是C++至高无上的荣耀。C函数指针一般有两种用法（正、反）。

C++中多态的实现原理

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

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

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

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

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

说明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");
}