多态--下

概念

优先使用组合、而不是继承;
继承会破坏父类的封装、因为子类也可以调用到父类的函数;
子类必须实现父类的纯虚函数;
内联函数没有地址,他是直接在定义的地方展开。所以不能是虚函数、虚函数是要有地址的;
虚函数不能是static函数,因为没有this指针、等于说是全局的,虚表要的是对象里面的;
普通函数继承是实现继承,就是不去重写父类的函数体,直接用的;虚函数的继承目的就是要重写这个函数体,自改成自己想要的;
虚函数在编译阶段就生成了,并且存在代码段;

析构函数最好写成多态。多态就是指向谁调谁,这样子类就可以调用自己的析构函数
构造函数不能写成多态;因为对象中的虚表指针实在初始化列表时开始初始化的;

多态如何实现的指向谁调谁?

虚函数的地址存在虚函数表中,通过虚函数表来调用虚函数;
同类型的对象共用一个虚表;
子类不重写父类的虚函数,也是和父类共用同一张虚表;重写就不会共用虚表

例子
#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;

class person
{
public:
	virtual void BuyTicket()
	{
		cout << "成人票" << endl;
	}
};

class student : public person
{
public:
	virtual void BuyTicket()
	{
		cout << "学生票" << endl;
	}
};


void buy(person& b)
{
	b.BuyTicket();
}


int main()
{
	student s;
	person p;
	buy(s);
	buy(p);
	return 0;
}
分析

1、子类继承后,虚函数表是一样的,重写后就把虚函数表copy出来换一个地址,把新的内容覆盖了;
image.png
2、调用时传过去的参数累心是谁的就指向谁的虚函数表,s是student类型那就是用student里面的函数;
image.png
2、子类虚函数不重写会怎样
如果不重写,那父级和子级虚函数表的地址是相同的
image.png

含有虚函数类的大小是多少?

普通函数不占空间,虚函数有个指针、所以站指针的大小空间,32位的4字节、64位的8字节;
在类里面:虚函数占一个指针的大小,不管有多少个虚函数就只占一个指针的大小;对象里面只是存了一个指针指向这个虚表
虚表的大小才要看有几个虚函数;
多继承的子类,继承了几个父类就有几个父类的指针大小
如下就一个虚函数64位
image.png
计算方法和结构体其实一样,内存对齐
加了一个int变量,理应8+4 = 12,但是最小对齐数为8,类的大小是其成员最小对齐数的整数倍;所以是16;
image.png

虚函数地址

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
using namespace std;

class person
{
public:
	virtual void BuyTicket()
	{
		cout << "成人票" << endl;
	}
private:
	int a;
};

class student : public person
{
public:
	virtual void BuyTicket()
	{
		cout << "学生票" << endl;
	}
};


void buy(person& b)
{
	b.BuyTicket();
}


class base
{
public:
	virtual void func1()
	{
		cout << "base::func1" << endl;
	}
private:
	int _b = 1;
};



void func()
{
	person b1;
	printf("vftptr:%p\n", *(int*) & b1);

	int i = 0;
	int* p1 = &i;
	int* p2 = new int;
	const char* p3 = "sad";
	printf("栈变量:%p\n", p1);
	printf("堆变量:%p\n", p2);
	printf("代码段常量:%p\n", p3);
	printf("代码段函数地址:%p\n", &base::func1);

}


int main()
{
	student s;
	person p;
	buy(s);
	buy(p);
	int size = sizeof(s);
	cout << size << endl;
	func();
	return 0;
}

问题:虚函数存在哪?虚函数表存在哪?
答:虚函数和普通函数都存在代码段、虚函数表也存在代码段
image.png
普通的函数、函数名就是地址(首地址)
成员函数的地址要加取地址符号&,以及要指定属于哪个类,也就是这样 &类名::函数名

虚表地址

class Base
{
public:
	virtual void fuc1(){cout << "fuc1" << endl;}
	virtual void fuc2(){cout << "fuc2" << endl;}
private:
	int a;
};

class derive : public Base
{
public:
	virtual void fuc1(){ cout << "fuc1111" << endl; }
	virtual void fuc3(){cout << "fuc3" << endl;}
};



typedef void(*VF_PTR)();//函数指针类型怎么写的
void PrintVFTable(VF_PTR* pTable)
{
	for(size_t i = 0; pTable[i] != 0; ++i)
	{
		printf("vfTable[%d]:%p->", i, pTable[i]);
		VF_PTR f = pTable[i];
		f();//运行函数
	}
	cout << endl;
}




int main()
{
	//student s;
	//person p;
	//buy(s);
	//buy(p);
	//int size = sizeof(s);
	//cout << size << endl;
	//func();

	derive a;
	Base b;
	PrintVFTable((VF_PTR*)(*(int*)&b));
	PrintVFTable((VF_PTR*)(*(int*)&a));

	return 0;
}

父类上面两行、子类为下面三行;
子类fuc1重写过了虚表地址就变了,没写fuc2但是继承了fuc2的虚表地址;
image.png
强转两次,(int*)是要取前4个字符,(VF_PTR*)强转函数指针
image.png
函数指针怎么写 void(*)()
type void(*a)(),这个a就代表函数指针了

多继承的子类的大小怎么计算?

继承几个父类就含有几个指针;

class Base1
{
public:
	virtual void fuc1() { cout << "b1:fuc1" << endl; }
	virtual void fuc2() { cout << "b1:fuc2" << endl; }
private:
	int a1;
};


class Base2
{
public:
	virtual void fuc1() { cout << "b2:fuc1" << endl; }
	virtual void fuc2() { cout << "b2:fuc2" << endl; }
private:
	int a2;
};

class derive2 : public Base1, public Base2
{
	virtual void fuc1() { cout << "b2:fuc1" << endl; }
	virtual void fuc3() { cout << "b2:fuc2" << endl; }

private:
	int a3;
};


int main()
{
	//student s;
	//person p;
	//buy(s);
	//buy(p);
	//int size = sizeof(s);
	//cout << size << endl;
	//func();

	//derive a;
	//Base b;
	//PrintVFTable((VF_PTR*)(*(int*)&b));
	//PrintVFTable((VF_PTR*)(*(int*)&a));

	cout << sizeof(derive2) << endl;
	derive2 a1;
	PrintVFTable((VF_PTR*)(*(int*)&a1));
	PrintVFTable((VF_PTR*)(*(int*)((char*)&a1 + sizeof(Base1))));

	return 0;
}

image.png
继承两个父类,两个指针的大小;
不同父类的虚表继承后不会共用;
derive2成员函数fuc3的虚表和Base1的虚表共用了,随机共用一个父类的虚表;

练习题

1、
image.png
2、
类中就只有变量、按顺序往下排;
p3是指向整块区域,所以首地址也是b1存的首地址;
p1也是b1存的首地址;
p2是b2的首地址;
所以选c;
image.png

虚函数和虚继承

image.png
是两个完全不同的概念;
用的都是virtual;

虚继承
image.png
菱形继承时,B、C继承A,D继承BC;

如上图使用虚继承,就会把公共的变量_a,放到一个地址上;
如果不用虚继承的话,就会有三个_a的地址;造成数据的冗余性;
二义性也是不用虚继承造成的,就是再回去找_a时,有很多_a;

相关推荐

  1. 继承 向上转型 向转型

    2024-04-03 09:00:02       7 阅读
  2. <span style='color:red;'>多</span><span style='color:red;'>态</span>

    2024-04-03 09:00:02      18 阅读

最近更新

  1. leetcode705-Design HashSet

    2024-04-03 09:00:02       8 阅读
  2. Unity发布webgl之后打开streamingAssets中的html文件

    2024-04-03 09:00:02       8 阅读
  3. vue3、vue2中nextTick源码解析

    2024-04-03 09:00:02       8 阅读
  4. 高级IO——React服务器简单实现

    2024-04-03 09:00:02       8 阅读
  5. 将图片数据转换为张量(Go并发处理)

    2024-04-03 09:00:02       7 阅读
  6. go第三方库go.uber.org介绍

    2024-04-03 09:00:02       8 阅读
  7. 前后端AES对称加密 前端TS 后端Go

    2024-04-03 09:00:02       10 阅读

热门阅读

  1. Echart(多雷达图展示)

    2024-04-03 09:00:02       4 阅读
  2. openmmlab系列框架多GPU训练

    2024-04-03 09:00:02       5 阅读
  3. 练气第六天

    2024-04-03 09:00:02       3 阅读
  4. openGauss 分布式分析能力

    2024-04-03 09:00:02       7 阅读
  5. PostCSS安装与使用技术详解

    2024-04-03 09:00:02       4 阅读
  6. CSS总结

    2024-04-03 09:00:02       6 阅读
  7. 拒绝服务攻击(Dos)与Tomcat的解决方法

    2024-04-03 09:00:02       6 阅读
  8. 读《C Primer Plus》

    2024-04-03 09:00:02       5 阅读