【C++】多态（万字详解） —— 条件 | 虚函数重写 | 抽象类 | 多态的原理

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

🌈欢迎来到C++专栏~~多态

  • (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort
  • 目前状态大三非科班啃C++中
  • 🌍博客主页张小姐的猫~江湖背景
  • 快上车🚘握好方向盘跟我有一起打天下嘞
  • 送给自己的一句鸡汤🤔
  • 🔥真正的大师永远怀着一颗学徒的心
  • 作者水平很有限如果发现错误可在评论区指正感谢🙏
  • 🎉🎉欢迎持续关注
    在这里插入图片描述

请添加图片描述

多态

请添加图片描述

前言

多态分为两类 ——

  • 静态的多态函数重载。传入不同参数看起来调用一个函数但是有不同的行为最典型的比如流插入流提取的“自动识别类型”
	int i = 10;
	double d = 1.1;
	cout << i; //cout.operator<<(int)
	cout << d; //cout.operator<<(double)
  • 动态的多态一个父类的引用或指针调用同一个函数传递不同的对象会调用不同的函数

怎么样区分呢

  • 静态在编译时决议(编译时决定调用谁)
  • 动态在运行时决议(运行时决定调用谁)

不过本文主要围绕的是动态的多态进行展开

一. 多态的概念

多态的概念通俗来说就是多种形态具体点就是去完成某个行为当不同的对象去完成时会产生出不同的状态

比如买票我们想让不同身份的人买票的价格不同就可以借助多态实现
在这里插入图片描述

class Person
{
public:
	virtual void BuyTicket() { cout << "买票——全价" << endl; }
};

class Student : public Person
{
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};

class Soldier : public Person
{
public:
	virtual void BuyTicket() { cout << "优先买票" << endl; }
};

void Func(Person& p)//父类的指针/引用
{
	p.BuyTicket();//虚函数重写
}

int main()
{
	Person ps;
	Student st;
	Soldier sd;
	Func(ps);//传父类对象 —— 调父类的
	Func(st);//传子类对象 —— 调子类的
	Func(sd);//传子类对象 —— 调子类的

	return 0;
}

其中子类的函数满足 三同(返回值类型、函数名、参数列表完全相同)的虚函数这两个条件叫做重写(覆盖)

ps:此时的函数名相同但是不构成隐藏不满足三同的才叫做隐藏
这样就可以什么人对应什么政策

在这里插入图片描述

二. 多态的定义及实现

🌈多态的条件

🥑多态有两个条件缺一不可

  • 必须通过父类的 指针或者引用调用虚函数
  • 被调用的函数必须是虚函数且派生类必须对基类的虚函数进行重写
    • 虚函数被virtual修饰的类成员函数
    • 重写要求 虚函数 + 三同父类和子类的返回值类型、函数名字、参数列表完全相同形参名和缺省参数名不一样不影响
  • 构成多态传的哪个类型的对象调用的就是哪个类型的虚函数 - 跟对象有关
  • 不构成多态调用的就是p类型函数 - 跟类型有关

下面进行验证如果用对象来调用够不够构成多态

void Func(Person p)
{
	p.BuyTicket();
}

在这里插入图片描述

我们思考为什么一定要是父类的指针或引用呢为什么是父类为什么是指针和引用

  1. 因为只有指针和引用访问才能实现晚绑定如果使用的是对象的话在编译期间就已经绑定完毕了也就是已经确定call好了地址了也就不能实现多态
  2. 我们知道一个子类的第一个成员是父类成员父类下的第一个就是虚表指针我们是要通过父类指针来找到这个虚表的如果是通过子类去访问就是静态绑定不能达到动态调节

没有重写的话是编译时决定还是运行时决定地址

在这里插入图片描述

调试打开反汇编可以看见是运行时决定的
在这里插入图片描述

此处的编译器并没有完全检查你是否重写只是初略的检查是否是虚函数以及父类指针调用但是调用的还是同一个虚函数因为没有完成覆盖

🌈虚函数重写的两个特例

🥑协变

协变返回值可以不同但要求必须是父子关系的指针或者引用

在这里插入图片描述
实际上用的不多

🥑析构函数的重写

如果析构函数构是虚函数这里构成重写吗yes但是他们的函数名不相同啊因为析构函数名被特殊处理了都处理成了destructor至于为什么要特殊处理就是源于多态

//建议在继承中析构函数定义成虚函数
class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};

class Student : public Person {
public:
	//析构函数名会被处理成destructor所以完成了重写
	virtual ~Student() { cout << "~Student()" << endl; }
};

int main()
{
	Person p;
	Student s;
	
	return 0;
}

在这里插入图片描述

普通的场景下是没有出现问题的但是有特殊的场景要记住面试高频考点

✨ 那什么场景下析构函数要是虚函数呢

	Person* ptr1 = new Person;
	delete ptr1;

	Person* ptr2 = new Student;
	delete ptr1;

如果不是虚函数那也就不构成多态那与类型有关都会去调用父类的析构函数但是这样会导致子类对象可能有资源未被清理我们希望的是父类调用父类指向子类调用子类的完了再调用父类这样是不是就符合我们多态的理念

在这里插入图片描述
析构函数的重写很简单因为函数名“相同”没有参数加一个virtual就可以

在这里插入图片描述
在其他场景析构函数是不是虚函数都可以

🌈只有父类带 virtual 的情况

虚函数允许父子类两个都是虚函数 或 只有父类是虚函数也行。这其实是C++不是很规范的地方建议两个都写上virtual

这是因为虽然子类没带virtual但是它 继承了父类的虚函数属性重写是实现

在这里插入图片描述

🌈C++11 final & override

🥑final

final有两个功能

  • 修饰一个类这个类不能被继承
  • 修饰虚函数限制它不能被子类中的虚函数重写

C++11中final还可以限制重写
修饰虚函数限制它不能被子类中的虚函数重写

在这里插入图片描述

🥑override

override放在子类重写的虚函数后面帮助检查是否完成重写没有重写会报错

类似于核酸检测没有做就报错做核酸魔怔了
在这里插入图片描述

三. 重载 vs 重写 vs 隐藏

在这里插入图片描述

四. 抽象类

💛 包含纯虚函数的类叫做抽象类(接口类)。在虚函数的后面写上=0 则这个函数为纯虚函数

纯虚函数一般只声明不实现抽象类不能实例化出对象相当于间接强制你重写

在这里插入图片描述

即使我们创造了一个子类对象其派生类继承后也不能实例化出对象因为继承了抽象类后这个派生类就继承了纯虚函数那它同样也是一个抽象类

只有重写纯虚函数派生类才能实例化出对象。所以呀抽象类本质上强制继承它的子类完成虚函数重写

class Car
{
public:
	virtual void Drive() = 0;
};

class BMW: public Car
{
public:
	virtual void Drive()
	{
		cout << "操控——好开" << endl;
	}
};

class Benz :public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};

int main()
{
	//BMW b;
	Car* ptr = new BMW;
	ptr->Drive();

	Car* ptr = new Benz;
	ptr->Drive();

	return 0;
}

在这里插入图片描述

ps虚函数的继承是一种接口继承派生类继承的是基类虚函数的接口目的是为了重写达成多态继承的是接口重写的是实现。所以如果不实现多态不要把函数定义成虚函数

五. 多态的原理

🔥虚函数表

⚡引入

// 其中sizeof(Base)是多少
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}

private:
	int _b = 1;
	char _ch = 'A';
};

int main()
{
	cout << sizeof(Base) << endl;
}

如果我只考虑到了内存对齐的话答案就是8

在这里插入图片描述

但此处的考点不仅仅只有内存对齐真正考察的是多态那究竟是什么东西的存在多了4个字节
通过监视窗口发现这个对象多了一个成员虚函数表指针_vfptrvirtual function table(简称虚表指针) 所谓的虚函数表就是一个指针数组里面存放的是函数指针(放的是虚函数地址)一般这个数组的最后面放了一个nullptr——

虚函数等等的函数都是放在代码段的

在这里插入图片描述

记住对象里面没有虚表只有指向虚表的指针

🔥多态的原理

虚函数表是理解多态原理的关键下面将在底层剖析

class Person {
public:
	virtual void BuyTicket() 
	{ cout << "买票-全价" << endl; }
protected:
	int _a = 0;
};

class Student : public Person 
{
public:
	virtual void BuyTicket() 
	{ cout << "买票-半价" << endl; }
protected:
	int _b = 0;
};

void Func(Person& p) {
	p.BuyTicket();
}

int main()
{
	Person Scort;
	Func(Scort);

	Student Durant;
	Func(Durant);

	return 0;
}

虚函数的“重写”也叫“覆盖”重写是语法上的概念覆盖是原理层的概念子类继承父类的虚函数可以认为深拷贝了一份虚函数表没有重写时子类与父类虚表完全相同若重写了便会用新地址覆盖。

🍂转到反汇编可以发现

  • 对于普通成员函数的调用是在编译后就已经确定了调用地址(橙色的)
  • 给父类/子类对象调用虚函数p.BuyTichet()的汇编代码却是相同的那就说明此时调用函数时不再是直接确定地址而是借助了eax这个寄存器这是多态原理的关键

在这里插入图片描述
汇编不要求全部看懂懂大概意思就可

🟢多态的本质原理基类的指针/引用指向谁就去谁的虚函数表中找到对应位置的虚函数进行调用这是在运行中确定的所以叫动态的多态

在这里插入图片描述

而普通函数在编译链接的时候已经确定了函数运行地址直接调用即可
在这里插入图片描述

🔥小细节

p1和p2是共用一个虚表吗

class Person 
{
public:
	virtual void BuyTicket() { cout << "买票——全价" << endl; }
};

int main()
{
	Person p1;
	Person p2;

	return 0;
}

在这里插入图片描述

结论是同一类型的对象共用一个虚表

class Person 
{
public:
	virtual void BuyTicket() { cout << "买票——全价" << endl; }
};

class Student :public Person {
public:
	//virtual void BuyTicket() { cout << "买票——半价" << endl; }
};

int main()
{
	Person p1;
	Person p2;

	Student s1;
	Student s2;

	return 0;
}

在这里插入图片描述

结论vs下不管是否完成重写子类虚表和父类的虚表不是同一个

🔥虚函数表在哪

那虚表在哪里呢我们就铺垫过虚函数表不能修改所以我猜测是在常量区的
我们写一段代码来验证一下 ——

在这里插入图片描述

所以虚函数表是存在“常量区”的

int main()
{
	int* ptr = (int*)malloc(4); 
	printf("heap: %p\n", ptr);

	int a = 0;
	printf("stack: %p\n", &a);

	static int s = 0;
	printf("数据段%p\n", &s);

	const char* p = "always";
	printf("常量区%p\n", p);

	printf("代码段%p\n", &Base::func1);

	Base b;
	// 取对象头4/8个字节 —— 强转(Base* -> int*) —— 再解引用拿到_vfptr
	printf("虚函数表: %p\n", *((int*)&b));

	return 0;
}

六. 单继承和多继承关系中的虚函数表

首先我们要再来观察如下代码在监视窗中的状况这儿vs起到了很好的误导作用我们来一一揭秘

class Person 
{
public:
	virtual void BuyTicket() { cout << "买票——全价" << endl; }

	virtual void func1()
	{}
};

class Student :public Person {
public:
	virtual void BuyTicket() { cout << "买票——半价" << endl; }

	virtual void func2()
	{}
};

int main()
{
	Person p1;
	Person p2;

	Student s1;
	Student s2;

	return 0;
}

ps:子类的虚函数在监视窗口是看不见的
但是func2还是要进虚表的

在这里插入图片描述

💦打印虚函数表

有时虚函数地址被隐藏掉了之前我们只能在内存窗口中观察现在我们来学习打印虚函数表

在这里插入图片描述

虚函数表中都是函数指针函数指针如何定义变量还记得吗不是函数名不是定义在最后的而是混杂其中的我们在typedef时依然保留了这个原则

//typedef void(*)() VFPTR; 这样定义是编译不过的要像函数指针定义一样
typedef void(*VFPTR)();

//打印虚函数表           vs下虚表最后才有nullptrlinux下没有
void PrintfVFTable(VFPTR table[])
{
	for (size_t i = 0; table[i] != nullptr; i++)
	{
		printf("vtf[%d]:%p", i, table[i]);
		VFPTR pf = table[i];
		pf();
	}
}

那么在调用这个函数的时候就需要传入虚函数表的地址即指针数组的(首元素)地址即对象中的虚表指针_vfptr

问题就转化成了如何取到对象头4/8个字节呢

两个没有关系的类型int 和 student是没办法直接强转成int那取&个地址变成student* 再转成 int*可是传入的参数类型还不匹配那就再(VF_PTR*)强转一下 ——

    //取对象头部虚函数表指针传递过去
	PrintfVFTable((VFPTR *)(*(int*)&s1));

一步步理顺先&s1变成student*再强转成int*解引用就是开头的4个字节了形参是VF_PTR[],类型是(VF_PTR*)最后再强转一下即可

出现打印不全的情况只需要重新生成一下解决方案即可

在这里插入图片描述

    PrintVFTable((VF_PTR*)(*(int*)&b));			// 32位
	PrintVFTable((VF_PTR*)(*(long long*)&b));	// 64位
	PrintVFTable((VF_PTR*)(*(void**)&b));		// 32/64位
  • 32位平台用(int*)强转
  • 64位平台用(long long*)强转

此处为什么就是void**(int*) 解引用看一个int的大小(long long*)解引用看的是long long的大小void* 不能解引用这(void**)解引用看的是void* 的大小void* 的大小就和平台相关

记住我们要取的是对象头四个子杰中的内容而不是地址这就是为什么要*解引用的作用
实际传的是二级指针

在这里插入图片描述

Linux下的写法与调用

//Linux下
void PrintfVFTable(VFPTR* table, size_t n)
{
	for (size_t i = 0; i < n; i++)
	{
		printf("vtf[%d]:%p ->", i, table[i]);
		VFPTR pf = table[i];
		pf();
	}
}

PrintfVFTable((VFPTR *)(*(int*)&s1, 3);

💦单继承的虚函数表

class Person
{
private:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int _a = 0;
};

class Student :public Person
{
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	void fun4() { cout << "func4()" << endl; }
private:
	int _b = 1;
};


//void(*ptr)();//函数指针

//typedef void(*)() VFPTR; 这样定义是编译不过的要像函数指针定义一样
typedef void(*VFPTR)();

//打印虚函数表           vs下虚表最后才有nullptrlinux下没有
//void PrintfVFTable(VFPTR table[])
//Linux下
void PrintfVFTable(VFPTR* table, size_t n)
{
	for (size_t i = 0; i < n; i++)
	{
		printf("vtf[%d]:%p ->", i, table[i]);
		VFPTR pf = table[i];
		pf();
	}
}

int main()
{
	Person p1;
	PrintfVFTable((VFPTR*)(*(int*)&p1), 2);
	cout << endl;

	Student s1;
	PrintfVFTable((VFPTR *)(*(int*)&s1),3);

	return 0;
}

在这里插入图片描述

💦多继承的虚函数表

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};

class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}

int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

我们首先来算一下Derive的大小

在这里插入图片描述

还是那句话vs下无法检测到子类新增的虚函数虚函数总会放进虚表的嘛那究竟是放进第一个虚表还是第二个虚表呢

我们打印一下虚表可以发现func3在第一个虚表中

在这里插入图片描述
那我们怎么样打印Base2的虚表呢

    //正常方法
	PrintVTable((VFPTR*)*((int*)((char*)&d + sizeof(Base1))));

	//切片方法
	Base2* ptr = &d;
	PrintVTable((VFPTR*)*((int*)(ptr)));

在这里插入图片描述

在这里插入图片描述

可见func3放进了第一个虚表中

在这里插入图片描述

并且即使子类重写了func1后你发现这对象虚表中Base1和Base2的虚函数func1的地址不一样你早就不应该感到惊奇因为这时jmp跳转指令的地址最终会一跳到同一位置执行函数Derive::func1的 ——

在这里插入图片描述

发现p2->func1()调用函数时还跳了好多层。这是为了做准备工作ecx-8 修正this指针(eax)为什么呢调用虚函数时要传递this指针-8由指向Base1到指向Base2从而看到对应类型视角下的那部分

💦菱形继承的虚函数表

实际中我们不建议设计出菱形继承及菱形虚拟继承一方面太复杂容易出问题另一方面这样的模型访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了一般我们也不需要研究清楚因为实际中很少用。可以去看下面的两篇链接

C++ 虚函数表解析 | 酷 壳 - CoolShell

C++ 对象的内存布局 | 酷 壳 - CoolShell

还是简简单单的说一下吧继续来上一段老代码

class A
{
public:
	virtual void f()
	{}
public:
	int _a;
};

class B : virtual public A 
{
public:
	int _b;
};

class C : virtual public A 
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	//d._a = 0; //不存在二义性可以直接找
	return 0;
}

在这里插入图片描述

在菱形继承中如果B和C都重写了A的虚函数func1那么D必须重写func1否则会报错“D”:“void A::f1(void)”的不明确继承因为这儿是虚继承共用一个虚表不知道用哪个重写

public:
	virtual void f1() {}
public:
	int _a;
};

class B : virtual public A 
{
public:
	virtual void f1() {}
	virtual void f2() {}
public:
	int _b;
};

class C : virtual public A 
{
public:
	virtual void f1() {}
	virtual void f2() {}
public:
	int _c;
};

class D : public B, public C
{
public:
	virtual void f1() {}
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

我们说过虚基表中曾经内容是00000000是为其他东西预留的那它究竟是什么呢这是找虚表的偏移量。

在这里插入图片描述

虚基表存的是偏移量用来解决数据冗余和二义性

虚函数表是存放虚函数的解决多态

所以通俗一点的说菱形继承谁用谁…

七. 常见考点总结

  1. 什么是多态
  2. 什么是重载、重写(覆盖)、重定义(隐藏)
  3. 多态的实现原理
  4. inline函数可以是虚函数吗
    答不可以因为内联函数没有地址但是虚函数地址要被填入到虚表中。不过是可以编译通过的因为inline只是个建议到底有没有展开要视情况而定若调用时不构成多态保持inline属性若构成多态则没有inline属性。
  5. 静态成员可以是虚函数吗
    答不能因为静态成员函数没有this指针使用类型::成员函数的调用方式无法访问虚函数表所以静态成员函数无法放进虚函数表。
  6. 构造函数可以是虚函数吗
    答不能因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
  7. 析构函数可以是虚函数吗 什么场景下析构函数是虚函数
    答可以并且最好把基类的析构函数定义成虚函数。
  8. 构造函数可以是虚函数吗
    答拷贝构造也是构造函数也有初始化列表答案和构造一样
  9. 赋值函数可以是虚函数吗
    答语法上可以但是没有意义
  10. 对象访问普通函数快还是虚函数更快
    答虚函数不构成多态就一样快虚函数构成多态的调用普通函数快因为多态调用时运行时决议。
  11. 虚函数表是在什么阶段生成的存在哪的
    答虚函数表是在编译阶段就生成的一般情况下存在**代码段(常量区)**的。
  12. C++菱形继承的问题虚继承的原理
    答注意这里不要把虚函数表和虚基表搞混了。
  13. 什么是抽象类抽象类的作用
    答查上面的。抽象类强制重写了虚函数另外抽象类体现出了接口继承关系

八. 经典题型讲解

1️⃣杀手题目

以下程序输出结果是什么

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

本题很老六不仅仅考了1️⃣多态还考了2️⃣接口继承的概念

  1. 首先test函数不满足多态func函数满足多态
  2. p是指向子类B的指针p传给test中的this指针是发生了切片因为是子类指针p传给父类指针this
  3. this 传给func函数this指向的是子类B所以func函数调用的就是子类B的func
    在这里插入图片描述到这里答案是不是要选D但是还有一个细节
  4. 此处的value值是1为什么呢因为重写是 接口继承普通函数是实现继承。接口继承就是函数主体架子都不变直接拿去使用加不加virtual、缺省值相不相同无所谓重写了是实现的部分
    在这里插入图片描述

答案选B

改编这样的话答案是选什么呢

int main(int argc, char* argv[])
{
	A* p = new B;
	p->test();
	return 0;
}
  • 答案没变还是选B,只是切片的地方发生了改变A* p = new B此处就发生了切片this指针还是指向子类B的所以调用func函数也会调用子类的
  • 正好符合多态的原理基类的指针/引用指向谁就去谁的虚函数表中找到对应位置的虚函数进行调用
  • 如果是A* p = new A就是调用父类A的

2️⃣杀手题目

class A {
public:
	A(char* s) { cout << s << endl; }
	~A() {}
};

class B :virtual public A
{
public:
	B(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
};

class C :virtual public A
{
public:
	C(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
};

class D :public B, public C
{
public:
	D(char* s1, char* s2, char* s3, char* s4) :B(s1, s2), C(s1, s3), A(s1)
	{
		cout << s4 << endl;
	}
};

int main() {
	D* p = new D("class A", "class B", "class C", "class D");
	delete p;
	return 0;
}

Aclass A class B class C class D Bclass D class B class C class A
Cclass D class C class B class A Dclass A class C class B class D

  • 首先A不会重复的初始化而且是按照声明顺序来的所以先初始化A
  • A不会在B和C中初始化因为D中只有一份A在其他两个中初始化都不合适只能在D中

所以答案选A

📢写在最后

恭喜球王梅西圆梦

请添加图片描述

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: c++
返回列表

上一篇：C++中你不知道的namespace和using的用法

下一篇：【C++】STL---vector的模拟实现(超级详细，万字详解)

“【C++】多态（万字详解） —— 条件 | 虚函数重写 | 抽象类 | 多态的原理” 的相关文章

C++中的引用处理1年前 (2023-02-02)
Leetcode：701. 二叉搜索树中的插入操作（C++）1年前 (2023-02-02)
VC++文件操作，获取文件属性信息，判断文件是否存在，移动和拷贝文件1年前 (2023-02-02)
C++——map|set介绍1年前 (2023-02-02)
c++-函数(1)1年前 (2023-02-02)
C++ 初了解模板1年前 (2023-02-02)
C++11条件变量：wait(lock),notify1年前 (2023-02-02)
C++ 高精度乘法运算1年前 (2023-02-02)
UE4c++日记1（允许 创类、蓝图读写/调用/只读、分类、输出日志打印语句）1年前 (2023-02-02)
剑指offer五道题，C++实现，看看自己能不能解出来。1年前 (2023-02-02)

阿里云国际版