《C++新经典对象模型》之第3章 虚函数

最新推荐文章于 2024-06-15 16:46:40 发布
最新推荐文章于 2024-06-15 16:46:40 发布
阅读量588 收藏 19
点赞数 14
分类专栏： 整理 C/C++ 学习 文章标签： c++ 对象模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oqqyx1234567/article/details/128911159
版权
整理 同时被 3 个专栏收录
181 篇文章 10 订阅
订阅专栏
学习
130 篇文章 4 订阅
订阅专栏
C/C++
92 篇文章 18 订阅
订阅专栏

《C++新经典对象模型》之第3章 虚函数

3.1 虚函数表指针位置分析

类有虚函数，就会产生虚函数表。
该类对象就会存在虚函数表指针，保存虚函数表的起始地址。
虚函数表指针位于对象内存的开头。

03.01.cpp
#include <iostream>
using namespace std;

class A
{
public:
	int i;
	virtual void testfunc() {}
};

int main()
{
	A a;
	char *p1 = reinterpret_cast<char *>(&a);	 // 0x006ff730 类型转换，这属于硬转，a是对象首地址
	char *p2 = reinterpret_cast<char *>(&(a.i)); // 0x006ff734
	if (p1 == p2)
		cout << "Virtual function table pointer located at the end of object memory" << endl;
	else
		cout << "Virtual function table pointer located at the start of object memory" << endl; // 本条件会成立

	cout << "Over!\n";
	return 0;
}

3.2 继承关系作用下虚函数的手工调用

通过虚函数表指针来调用虚函数。
父类与子类的虚函数表不同，内部保存的虚函数指针有差异（子类覆盖父类）。

03.02.cpp
#include <cstdio>
#include <iostream>
using namespace std;

class Base
{
public:
	virtual void f()
	{
		cout << "Base::f()" << endl;
	}
	virtual void g()
	{
		cout << "Base::g()" << endl;
	}
	virtual void h()
	{
		cout << "Base::h()" << endl;
	}
};
class Derive : public Base
{
public:
	void g()
	{
		cout << "Derive::g()" << endl;
	}
};

int main()
{
	cout << sizeof(Base) << endl;	// 8字节，虚函数表指针，x64平台
	cout << sizeof(Derive) << endl; // 8字节

	Derive *d = new Derive(); // 类指针
	// Base *d = new Derive();//等价

	long ***pvptr = (long ***)d; // 类指针转为虚函数表指针（三级指针）
	long **vptr = *pvptr;		 // 虚函数表指针取值得到虚函数表（二级指针）

	for (int i = 0; vptr[i] != nullptr; i++)
		printf("vptr[%d] = 0x:%p\n", i, vptr[i]); // 虚函数地址（一级指针）

	typedef void (*Func)(void); // 定义Func是函数指针类型
	Func f = (Func)vptr[0];		// 函数指针变量
	f();						// Base::f()
	Func g = (Func)vptr[1];
	g(); // Derive::g()   子类覆盖父类的虚函数
	Func h = (Func)vptr[2];
	h(); // Base::h()

	Func i = (Func)vptr[3];
	// i();					// 运行异常

	//---------------------------
	Base *dpar = new Base();
	long ***pvptrpar = (long ***)dpar;
	long **vptrpar = *pvptrpar;
	for (int i = 0; vptrpar[i] != nullptr; i++)
		printf("vptr_Base [%d] = 0x:%p\n", i, vptrpar[i]);

	Func fpar = (Func)vptrpar[0]; // project4.exe!Base::f(void)}
	Func gpar = (Func)vptrpar[1]; // project4.exe!Base::g(void)}
	Func hpar = (Func)vptrpar[2]; // project4.exe!Base::h(void)}
	Func ipar = (Func)vptrpar[3];
	fpar(); // base::f
	gpar(); // base::g
	hpar(); // base::h
	//ipar();       //运行异常

	cout << "Over!\n";
	return 0;
}

3.3 虚函数表分析

（1）含虚函数的类才有虚函数表（二级指针，内部多个虚函数【一级函数指针】编译时已经固定，子类覆盖父类），各个类对象（实例）有各自的vptr（虚函数表指针，三级指针），地址不同，但都指向类的虚函数表。
（2）父类有虚函数则子类也有虚函数。
（3）子类无新的虚函数时，则与父类的虚函数表的内容相同，虚函数表的地址不同。
（4）超出虚函数表部分内容不可知也不可预测，不一定为nullptr。

Base base = drive;
//生成base对象
//用derive初始化base对象的值
//derive初始化base对象时，derive的虚函数表指针值未覆盖base对象的虚函数表指针值

面向对象模型——OOM（Object-Oriented Model），通过类对象的指针和引用来支持多态。
基于对象——OB（Object-Based），抽象数据模型ADT（Abstract Datatype Model），不支持多态，运行更快，函数调用编译时就解析完成，内存空间更紧凑。

03.03.cpp
#include <cstdio>
#include <iostream>
using namespace std;

class Base
{
public:
	virtual void f()
	{
		cout << "Base::f()" << endl;
	}
	virtual void g()
	{
		cout << "Base::g()" << endl;
	}
	virtual void h()
	{
		cout << "Base::h()" << endl;
	}
};
class Derive : public Base
{
public:
	void g()
	{
		cout << "Derive::g()" << endl;
	}
};

int main()
{
	cout << sizeof(Base) << endl;	// 8字节，虚函数表指针，x64平台
	cout << sizeof(Derive) << endl; // 8字节

	Derive *d = new Derive(); // 类指针
	// Base *d = new Derive();//等价

	long ***pvptr = (long ***)d; // 类指针转为虚函数表指针（三级指针）
	long **vptr = *pvptr;		 // 虚函数表指针取值得到虚函数表（二级指针）

	for (int i = 0; vptr[i] != nullptr; i++)
		printf("vptr[%d] = 0x:%p\n", i, vptr[i]); // 虚函数地址（一级指针）

	typedef void (*Func)(void); // 定义Func是函数指针类型
	Func f = (Func)vptr[0];		// 函数指针变量
	f();						// Base::f()
	Func g = (Func)vptr[1];
	g(); // Derive::g()   子类覆盖父类的虚函数
	Func h = (Func)vptr[2];
	h(); // Base::h()

	Func i = (Func)vptr[3];
	// i();					// 运行异常

	//---------------------------
	Base *dpar = new Base();
	long ***pvptrpar = (long ***)dpar;
	long **vptrpar = *pvptrpar;
	for (int i = 0; vptrpar[i] != nullptr; i++)
		printf("vptr_Base [%d] = 0x:%p\n", i, vptrpar[i]);

	Func fpar = (Func)vptrpar[0]; // project4.exe!Base::f(void)}
	Func gpar = (Func)vptrpar[1]; // project4.exe!Base::g(void)}
	Func hpar = (Func)vptrpar[2]; // project4.exe!Base::h(void)}
	Func ipar = (Func)vptrpar[3];
	fpar(); // base::f
	gpar(); // base::g
	hpar(); // base::h
	//ipar();       //运行异常

	cout << "Over!\n";
	return 0;
}

3.4 多重继承虚函数表分析

（1）虚函数表跟着类，虚函数表指针跟着对象。
（2）类有多个含虚函数的父类，则该对象有多个虚函数表指针（类最多只有一个虚函数表）。
（3）虚函数表指针按继承顺序放置在内存空间中，且子类与第一个父类共用同一个虚函数表指针。
（4）子类虚函数覆盖父类同名虚函数。

03.04.cpp
#include <stdio.h>
#include <iostream>
using namespace std;

// 父类1
class Base1
{
public:
	virtual void f()
	{
		cout << "base1::f()" << endl;
	}

	virtual void g()
	{
		cout << "base1::g()" << endl;
	}
};

// 父类2
class Base2
{
public:
	virtual void h()
	{
		cout << "base2::h()" << endl;
	}
	virtual void i()
	{
		cout << "base2::i()" << endl;
	}
};

// 子类
class Derived : public Base1, public Base2
{
public:
	virtual void f()
	{
		cout << "derived::f()" << endl; // 只覆盖base1的f
	}

	virtual void i()
	{
		cout << "derived::i()" << endl; // 只覆盖base2的i
	}

	// 如下三个是本类自己的虚函数
	virtual void mh()
	{
		cout << "derived::mh()" << endl;
	}
	virtual void mi()
	{
		cout << "derived::mi()" << endl;
	}
	virtual void mj()
	{
		cout << "derived::mj()" << endl;
	}
};

int main()
{
	cout << sizeof(Base1) << endl;	 // 8
	cout << sizeof(Base2) << endl;	 // 8
	cout << sizeof(Derived) << endl; // 16字节，两个虚函数表指针（2个vptr）

	Derived ins; // 定义一个子类对象

	Base1 &b1 = ins;
	Base2 &b2 = ins;
	Derived &d = ins;
	b1.f(); // derived::f()，父类引用，但引用的是子类，所以这里执行子类所覆盖的父类的虚函数
	b2.i(); // dervied::i()，父类引用，但引用的是子类，所以这里执行子类所覆盖的父类的虚函数
	d.f();	// derived::f()
	d.i();	// derived::i()
	d.mh(); // derived::mh()

	cout << "********************\n";

	long ***pderived1 = (long ***)(&ins);
	long **vptr1 = pderived1[0]; // 第一个虚函数表指针，根据继承顺序，和base1对应
	long **vptr2 = pderived1[1]; // 往后走8个字节, 第二个虚函数表指针

	typedef void (*Func)(void);
	// 第一个父类虚函数（子类重写则覆盖）+子类虚函数
	Func f1 = (Func)vptr1[0]; // 0x00f31550 {project100.exe!Derived::f(void)}
	f1();
	Func f2 = (Func)vptr1[1]; // 0x00f31596 {project100.exe!Base1::g(void)}
	f2();
	Func f3 = (Func)vptr1[2]; // 0x00f31578 {project100.exe!Derived::mh(void)}
	f3();
	Func f4 = (Func)vptr1[3]; // 0x00f31582 {project100.exe!Derived::mi(void)}
	f4();
	Func f5 = (Func)vptr1[4]; // 0x00f3157d {project100.exe!Derived::mj(void)}
	f5();
	Func f6 = (Func)vptr1[5]; // 0x0029aa64 {project100.exe!const Derived::`RTTI Complete Object Locator'{for `Base2'}}
	f6();
	Func f7 = (Func)vptr1[6];
	// f7(); //error

	// 第二个父类虚函数（子类重写则覆盖）
	Func f11 = (Func)vptr2[0]; // 0x00291587 {project100.exe!Base2::h(void)}
	f11();
	Func f22 = (Func)vptr2[1]; // 0x00291591 {project100.exe!Derived::i(void)}
	f22();
	Func f33 = (Func)vptr2[2]; // 非法
	// f33();					   // error

	cout << "Over!\n";
	return 0;
}

3.5 辅助工具与vptr、vtbl创建时机

3.5.1 使用辅助工具查看虚函数表

//打出MyProject.cpp文件中，类Derived的内存布局
cl /d1 reportSingleClassLayoutDerived MyProject.cpp

//生成.class文件，里面有类的布局信息
g++ -fdump-class-hierarchy -fsyntax-only MyProject.cpp

3.5.2 虚函数表的创建时机

（1）编译器在编译期间（不是运行期间），为每个含虚函数的类确定好了对应的虚函数表vtbl的内容。
（2）同样在编译期间在类构造函数中添加给虚函数表指针vptr赋值的语句，这样运行时，生成类对象，调用构造函数时，会为vptr赋值。
（3）可执行程序装载到内存后，会分配各种内存空间。代码段、数据段、堆区、栈区。

Derived *obj = new Derived();

obj指针在栈上，指向一个堆区（Derived实例），该实例中的虚函数表指针在执行类构造函数后，指向数据段中的该类的虚函数表，而虚函数表中每一项指向代码段中的虚函数。

3.6 单纯的类不纯时引发的虚函数调用问题

单纯类

class X0
{
public:
	int x;
	int y;
	int z;
	X0()
	{
		memset(this, 0, sizeof(X));
		cout << "X0:X0()" << endl;
	}

	X0(const X0 &tm)
	{
		memcpy(this, &tm, sizeof(X));
		cout << "X0:X0(const X&)" << endl;
	}
};

		X0 x0;
		x0.x = 100;
		x0.y = 200;
		x0.z = 300;
		X0 x1(x0);
		cout << "x1.x=" << x1.x << ", x1.y=" << x1.y << ", x1.z=" << x1.z << endl;

不单纯类，含有隐藏的成员变量，它的赋值往往在执行构造或者拷贝构造函数体之前。
构造函数中，memset时，隐藏成员变量值也会清零。
拷贝构造函数中，memset时，隐藏成员变量值会一致（实际可能应该不一致）。

//无继承关系时，虚函数和普通函数没有区别
//虚函数和函数一样，跟着类走
class X
{
public:
	int x;
	int y;
	int z;
	/*X() : x(0), y(0), z(0)
	{
		cout << "X:X()" << endl;
	}*/
	X()
	{
		memset(this, 0, sizeof(X));
		cout << "X:X()" << endl;
	}

	/*X(const X &tm) : x(tm.x), y(tm.y), z(tm.z)
	{
		cout << "X:X(const X&)" << endl;
	}*/
	X(const X &tm)
	{
		memcpy(this, &tm, sizeof(X));
		cout << "X:X(const X&)" << endl;
	}

public:
	virtual ~X()
	{
		cout << "X:virtual ~X()" << endl;
	}
	virtual void virfunc()
	{
		cout << "virtual virfunc()" << endl;
	}
	void ptfunc()
	{
		cout << "ptfunc()" << endl;
	}
};

{
		X x0;
		x0.x = 100;
		x0.y = 200;
		x0.z = 300;
		X x1(x0);
		cout << "x1.x=" << x1.x << ", x1.y=" << x1.y << ", x1.z=" << x1.z << endl;

		x0.virfunc();
	}

	{
		X *px0 = new X();
		px0->ptfunc(); // 可以正常调用普通该函数

		// px0->virfunc(); // 无法正常调用该虚函数
		// delete px0;		// 无法正常调用析构函数
	}

	{
		int i = 9;
		printf("&i = %p\n", &i); // 会发现每次i的地址输出出来都不一样
		//普通函数和虚函数地址编译时已经确定，不会变化
		printf("&X::ptfunc = %p\n", &X::ptfunc); // 正常函数地址可以这样输出
		printf("&X::virfunc = %p\n", &X::virfunc); // 正常函数地址可以这样输出

		X x0;
		long ***pvptr = (long ***)(&x0);
		long **vptr = *pvptr;
		printf("vptr[1] = %p\n", vptr);

		x0.ptfunc();  //
		x0.virfunc(); // 虚函数是可以正常调用的(编译时已固定地址，绑定，未使用虚函数表)
	}

	{
		X *pX0 = new X();
		pX0->ptfunc(); //直接调用，静态联编
		// pX0->virfunc();//error，通过虚函数表查找调用

		X x1;
		X &x1y = x1;   // 引用
		x1y.virfunc(); //
	}

（1）静态联编：编译时就确定调用的函数，调用语句和调用函数绑定在一起。
（2）动态联编：程序运行时，绑定调用语句和调用函数，多态和虚函数情况下存在。

03.06.cpp
#include <cstring>
#include <iostream>
using namespace std;

class X0
{
public:
	int x;
	int y;
	int z;
	X0()
	{
		memset(this, 0, sizeof(X0));
		cout << "X0:X0()" << endl;
	}

	X0(const X0 &tm)
	{
		memcpy(this, &tm, sizeof(X0));
		cout << "X0:X0(const X0&)" << endl;
	}
};

class X
{
public:
	int x;
	int y;
	int z;
	/*X() : x(0), y(0), z(0)
	{
		cout << "X:X()" << endl;
	}*/
	X()
	{
		memset(this, 0, sizeof(X));
		cout << "X:X()" << endl;
	}

	/*X(const X &tm) : x(tm.x), y(tm.y), z(tm.z)
	{
		cout << "X:X(const X&)" << endl;
	}*/
	X(const X &tm)
	{
		memcpy(this, &tm, sizeof(X));
		cout << "X:X(const X&)" << endl;
	}

public:
	virtual ~X()
	{
		cout << "X:virtual ~X()" << endl;
	}
	virtual void virfunc()
	{
		cout << "virtual virfunc()" << endl;
	}
	void ptfunc()
	{
		cout << "ptfunc()" << endl;
	}
};

int main()
{
	{
		X0 x0;
		x0.x = 100;
		x0.y = 200;
		x0.z = 300;
		X0 x1(x0);
		cout << "x1.x=" << x1.x << ", x1.y=" << x1.y << ", x1.z=" << x1.z << endl;
	}

	{
		X x0;
		x0.x = 100;
		x0.y = 200;
		x0.z = 300;
		X x1(x0);
		cout << "x1.x=" << x1.x << ", x1.y=" << x1.y << ", x1.z=" << x1.z << endl;

		x0.virfunc();
	}

	{
		X *px0 = new X();
		px0->ptfunc(); // 可以正常调用普通该函数

		// px0->virfunc(); // 无法正常调用该虚函数
		// delete px0;		// 无法正常调用析构函数
	}

	{
		int i = 9;
		printf("&i = %p\n", &i); // 会发现每次i的地址输出出来都不一样

		printf("&X::ptfunc = %p\n", &X::ptfunc); // 正常函数地址可以这样输出
		printf("&X::virfunc = %p\n", &X::virfunc); // 正常函数地址可以这样输出

		X x0;
		long ***pvptr = (long ***)(&x0);
		long **vptr = *pvptr;
		printf("vptr[1] = %p\n", vptr);

		x0.ptfunc();
		x0.virfunc(); // 虚函数是可以正常调用的
	}

	{
		X *pX0 = new X();
		pX0->ptfunc();
		// pX0->virfunc();//error

		X x1;
		X &x1y = x1;   // 引用
		x1y.virfunc(); //
	}

	cout << "Over!\n";
	return 0;
}
mali378287007
关注
  • 14
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++对象模型总结
10-09
第3章 Data语意学 第4章 Function语意学 第5章 构造、析构、拷贝语意学 第6章 执行期语意学 第7章 站在对象模型的尖端 第8章 C++对象模型总结 8.1 C++对象模型 8.2 单继承 8.2.1 无重写的单继承 8.2.2 有重写的单...
C++对象模型详解
02-20
对于各种支持的底层实现机制语言中直接支持面向对象程序设计的部分，如构造函数、析构函数、虚函数、继承（单继承、多继承、虚继承）、多态等等，这也是组里其他同学之前分享过的内容。第一部分这里我简单过一下，...
一文读懂C++虚函数的内存模型
热门推荐
彼方的博客
06-26 1万+
一文彻底读懂C++虚函数表的实现机制（使用GDB内存布局）1、虚函数简介2、虚函数表简介3、有继承关系的虚函数表剖析3.1、单继承无虚函数覆盖的情况3.2、单继承有虚函数覆盖的情况3.3、多重继承的情况3.4、多层继承的情况4、总结 1、虚函数简介 C++中有两种方式实现多态，即重载和覆盖。 重载：是指允许存在多个同名函数，而这些函数的参数表不同（参数个数不同、参数类型不同或者两者都不同）。 覆盖：是指子类重新定义父类的虚函数的做法，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际
C++对象模型 第二章 虚函数
qq_53111905的博客
11-20 782
编程语言和类型论中，多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口。 多态类型（英语：polymorphic type）可以将自身所支持的操作套用到其它类型的值上。 多态还可分为： 动态多态（dynamic polymorphism）:通过类继承机制和虚函数机制生效于运行期。可以优雅地处理异质对象集合，只要其共同的基类定义了虚函数的接口。也被称为子类型多态（Subtype polymorphism）或包含多态（inclusion polymorphism）。在面向对象程序设.
C++【对象模型】| 虚函数表 & 多态如何调用虚函数
weixin_45926547的博客
04-03 719
文章目录一、对象模型二、虚函数表1、虚函数 C++ | 【03】类的【继承、多态、复合、委托】 一、对象模型 二、虚函数表 当改类中存在虚函数或其基类含有虚函数，编译器将会添加一个虚函数表vptr； 1、虚函数 一个函数在类中声明时，在头部加上virtual即被声明为虚函数； ...
《深度探索c++对象模型》第一章笔记
StudyWinter的博客
07-10 649
这里所说的 base class table被产生出来时，表格中的每一个slot内含一个相关的 base class地址，这很像virtual table 内含每一个virtual function 的地址一样.每一个class object内含一个bptr，它会被初始化，指向其base class table。其实还是C++对象模型，但是这里更具体的说明了虚函数表的第0个位置指向X的type_info object，虚函数表的第1个位置指向虚析构函数，虚函数表的第2个位置指向X::foo()函数。
C++ 中的虚函数及虚函数表
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
04-07 1656
虚函数及虚函数表的定义、虚函数表指针和虚函数表的创建时机、虚函数实现多态的原理
深度解读《深度探索C++对象模型》之C++虚函数实现分析与效率评测（二）
iShare_Carlos的博客
04-24 1095
本系列深入分析编译器对于C++虚函数的底层实现，最后分析C++在多态的情况下的性能是否有受影响，多态究竟有多大的性能损失。
深度解读《深度探索C++对象模型》之C++虚函数实现分析与效率评测（一）
iShare_Carlos的博客
04-23 1165
本系列深入分析编译器对于C++虚函数的底层实现，最后分析C++在多态的情况下的性能是否有受影响，多态究竟有多大的性能损失。
C++多态虚函数实现原理，对象和虚函数表的内存布局
回头太难
05-17 2672
基本概念 我们知道C++动态多态是用虚函数实现的，而虚函数的实现方式虽说C++标准没有要求，但是基本都是用虚函数表实现的（编译器决定）。所以我们有必要了解一下虚函数表的实现原理。 用virtual关键字声明的成员函数是虚函数。 具有虚函数的类及其派生的类会在编译时创建虚函数表，简称虚表（vtbl），虚表是虚函数指针的数组。 具有虚函数的类对象有一个虚表指针（vfptr），是编译器生成的指针，在对象构造时初始化。虚表指针vfptr指向虚表的第一个虚函数指针（即vfptr的值是虚表第一个...
深度解读《深度探索C++对象模型》之C++虚函数实现分析与效率评测（四）
iShare_Carlos的博客
04-26 509
本系列深入分析编译器对于C++虚函数的底层实现，最后分析C++在多态的情况下的性能是否有受影响，多态究竟有多大的性能损失。
c++对象模型05：虚继承内存布局
effort_study的博客
08-07 3055
虚继承 虚继承解决了菱形继承中最派生类拥有多个间接父类实例的情况。虚继承的派生类的内存布局与普通继承很多不同，主要体现在： 虚继承的派生类，如果定义了新的虚函数，则编译器为其生成一个虚函数指针（vptr）以及一张虚函数表。该vptr位于对象内存最前面。（非虚继承时，派生类新的虚函数直接扩展在基类虚函数表的下面。） 虚继承的派生类有单独的虚函数表，基类也有单独的虚函数表，两部分之间用一个四个字节的0x00000000来作为分界。 虚继承的派生类对象中，含有四字节的虚基表指针。 在C++对象模型中，虚继承而
C++面向对象总结
01-10
面向对象编程是软件开发的第三步，它使用面向对象的编程语言来实现软件的功能。面向对象测试是软件开发的第四步，它确保软件的正确性和可靠性。 C++中的对象是类的一个实例，它具有自己的数据和行为。对象的成员...
C++ Primer第四版【中文高清扫描版】.pdf
03-13
第3章　标准库类型 67 3.1 命名空间的using声明 68 3.2 标准库string类型 70 3.2.1 string对象的定义和初始化 70 3.2.2 String对象的读写 71 3.2.3 string对象的操作 72 3.2.4 string对象中字符的处理 76 3.3 标准库...
吕鑫：《VC++就业培训宝典之MFC视频教程》第十二章 第三节 分隔器窗口开发
12-02
1、深入讲解PreCreateWindow虚函数对框架和视图的创建过程的影响； 2、演示最简单的分隔器窗口（Frame-Splitter模型）的开发方法；
CSAPP大作业 hello的一生
m0_73927795的博客
06-14 942
计算机系统大作业 hello的一生
【C++提高编程-05】----C++之Deque容器实战
最新发布
一伦明悦的博客
06-15 1102
Deque（双端队列）是C++ STL中的一种序列容器
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1050
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++|哈希结构封装unordered_set和unordered_map
weixin_68201503的博客
06-11 865
上一篇章，学习了unordered系列容器的使用，以及哈希结构，那么这一篇章将通过哈希结构来封装unordered系列容器，来进一步的学习他们的使用以及理解为何是如此使用。其实，哈希表的封装方式和红黑树的封装方式形式上是差不多的，如果有了红黑树的封装理解经验，我相信在理解哈希封装的过程会减少负担的。当然，在使用哈希结构中采用的是更具代表的哈希桶，接下来进行封装。
c++ 虚函数 经典例题
09-06
虚函数是面向对象编程中的重要概念之一。它允许在基类中定义一个函数，然后由派生类进行重写，实现多态的特性。下面是一个经典的虚函数例题。 假设有一个基类Animal（动物），它有一个虚函数sound（发出声音）。派生类Cat（猫）和Dog（狗）都继承自Animal类，但它们会发出不同的声音。 在基类Animal中，我们定义一个虚函数sound()，它只输出"动物发出声音"。在派生类Cat和Dog中，我们分别重写这个虚函数，Cat类中的sound()输出"猫发出喵喵声"，Dog类中的sound()输出"狗发出汪汪声"。 接下来，我们创建Animal类的指针并分别指向Cat和Dog对象，然后通过这个指针调用sound()函数。由于sound()是一个虚函数，在运行时会根据指针所指向的对象的实际类型来决定调用哪个版本的sound()函数。因此，当指针指向Cat对象时，调用sound()函数会输出"猫发出喵喵声"；当指针指向Dog对象时，调用sound()函数会输出"狗发出汪汪声"。 这个例题展示了虚函数的多态性。通过一个指向基类的指针，我们可以调用不同派生类中的同名函数，实现了动态绑定和运行时多态的效果。虚函数是面向对象编程中非常重要的特性，可以让代码更加灵活和可扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值