【c++】全面理解C++多态：虚函数表深度剖析与实践应用

最新推荐文章于 2024-05-19 22:51:15 发布
最新推荐文章于 2024-05-19 22:51:15 发布
阅读量2.3k 收藏 156
点赞数 188
分类专栏： c++笔记仓 文章标签： c++ android 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/arf_dog/article/details/138666480
版权

Alt

🔥个人主页：Quitecoder

🔥专栏：c++笔记仓

Alt

朋友们大家好，通过本篇文章，来详细理解多态的内容

目录

1.多态的定义及实现

多态的基本概念：多态指的是对象可以通过指向它们的基类的引用或指针被操纵，同时还能保持其派生类部分的特性。将派生类对象当作基类对象来对待，这允许不同类的对象响应相同的消息以不同的方式，换句话说，同一个接口，使用不同的实例而执行不同操作

比如买票，普通人买票时，是全价买票；学生买票时，是半价买票

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

在这里插入图片描述
普通人全价，学生半价

1.1多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价

那么在继承中要构成多态还有两个条件：

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

在这里插入图片描述
指向谁调用谁

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

如果这样调用，就不是指针或引用了，现在就不是多态：
在这里插入图片描述

1.2虚函数的重写

虚函数：即被virtual修饰的类成员函数称为虚函数

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

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数

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

虚函数重写的三个例外：

  1. 协变(基类与派生类虚函数返回值类型不同)：
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
class A {};
class B : public A {};
class Person {
public:
	virtual A* f() { return new A; }
};
class Student : public Person {
public:
	virtual B* f() { return new B; }
};
  1. 析构函数的重写(基类与派生类析构函数的名字不同)
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor

只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};

int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

当我们通过基类的指针来删除一个派生类的对象时，如果基类的析构函数没有被声明为虚拟的（virtual），将会发生对象的不完全析构。这意味着只有基类的析构代码会被执行，而派生类的析构逻辑不会调用，可能导致资源泄露或其他问题。

在给定的代码中，Person 类的析构函数被声明为虚拟的：

virtual ~Person() { cout << "~Person()" << endl; }

这意味着任何从 Person 派生的类，像 Student，都应该提供析构函数的一个覆盖版本：

virtual ~Student() { cout << "~Student()" << endl; }

当 delete p2; 被执行的时候（其中 p2 是一个基类 Person 类型的指针，指向一个 Student 对象），Student 的析构函数首先会被调用（子类），然后是 Person 的析构函数（基类）

因此，重写基类的虚拟析构函数确保了当通过基类指向派生类对象的指针进行 delete 操作时，能够按照正确的顺序调用派生类和基类的析构函数

  1. 派生类可以不写virtual
class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	void BuyTicket() { cout << "买票-半价" << endl; }
};

在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用

1.3 C++11 override 和 final

C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写

  1. final：修饰虚函数，表示该虚函数不能再被重写
class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};

在这里插入图片描述

用final修饰的类叫做最终类，不能被继承

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

在这里插入图片描述

  1. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错
class Car {
public:
	virtual void Drive() {}
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

在这里插入图片描述

1.4重载、覆盖(重写)、隐藏(重定义)的对比

重载发生在同一作用域内。当两个或者更多的函数拥有相同的名字，但是**参数列表不同（参数类型、参数个数或者参数顺序不同）**时，这些函数被称为重载函数。

class MyClass {
public:
    void func() 
    void func(int i)
    void func(double d) 
};

重写仅在基类和派生类之间发生，且只针对虚函数。当派生类定义一个与基类中虚函数签名完全相同的函数时（即函数名、参数列表和返回类型相同），派生类函数会覆盖（重写）基类中对应的虚函数。这是多态的基础，使得在运行时可以通过基类的指针或引用调用派生类的函数实现

示例：

class Base {
public:
    virtual void func() { /* ... */ }
};

class Derived : public Base {
public:
    void func() override { /* ... */ } // 覆盖（重写）基类中的func
};

隐藏也是在类的继承关系中发生，但它和是否为虚函数无关。在派生类中定义了一个新的函数，如果这个函数的名字与基类中的某个函数的名字相同，但是参数列表不同，那么它会隐藏（也称为重定义）所有与它同名的基类函数，不论基类中同名函数参数列表如何

示例：

class Base {
public:
    void func() { /* ... */ }
    void func(int i) { /* ... */ }
};

class Derived : public Base {
public:
    void func(double d) { /* ... */ } // 隐藏了基类的func()
    // 注意：现在Base的func()和func(int)都被隐藏，只能通过Derived的对象访问新的func(double)
};

在继承的类中隐藏了基类中的同名函数（不论是重载还是同签名的函数），如果想要调用被隐藏的函数，需要显式地指明作用域：

Derived obj;
obj.Base::func(); // 显式调用Base类中被隐藏的func()
obj.Base::func(42); // 显式调用Base类中被隐藏的func(int)
obj.func(3.14); // 调用Derived类中的func(double)

两个基类和派生类的同名函数，不构成重写就是隐藏

2.多态的原理

2.1虚函数表

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

sizeof(Base)是多少？
答案是8，我们进行测试观察：

在这里插入图片描述
除了_b成员，还多一个__vfptr放在对象的前面，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表
用内存窗口观察：
在这里插入图片描述
它是占八个字节的

2.2多态的原理

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

private:
	int _i = 1;
};

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

	int _j = 2;
};

void Func(Person* p)
{
	p->BuyTicket();
}

int main()
{
	Person Mike;
	Func(&Mike);

	Student Johnson;
	Func(&Johnson);

	return 0;
}

在这里插入图片描述

这里的指向父类调父类，指向子类调子类是怎么实现的呢？ 我们进行调试

在这里插入图片描述
在这里插入图片描述

Johnson首先继承了父类的部分，有虚表和虚表指针，这两个虚表指针不一样，他们指向内容不一样，一个指向父类的Buyticket，另一个指向子类的

p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数Person::BuyTicket
p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket

这样就实现出了不同对象去完成同一行为时，展现出不同的形态

反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么

满足多态条件，这里的调用生成的指令就会指向对象的虚表中找对应的虚函数调用

满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的

	p->BuyTicket();
009924E1  mov         eax,dword ptr [p]  
009924E4  mov         edx,dword ptr [eax]  
009924E6  mov         esi,esp  
009924E8  mov         ecx,dword ptr [p]  
009924EB  mov         eax,dword ptr [edx]  
009924ED  call        eax  
009924EF  cmp         esi,esp  
009924F1  call        __RTC_CheckEsp (09912B2h)

满足多态的情况下

  • p中存的是mike对象的指针，将p移动到eax中

  • [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx

  • [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax

  • call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的中取找的

同类型共用一个虚表：

Person Mike;
Func(&Mike);

Person p1;
Func(&p1);

在这里插入图片描述
现在如果不满足多态呢？

我将父类进行修改

class Person {
public:
	void BuyTicket() { cout << "买票-全价" << endl; }
private:
	int _i = 1;
};

	p->BuyTicket();
005B24E1  mov         ecx,dword ptr [p]  
005B24E4  call        Person::BuyTicket (05B149Ch)

它在编译链接时就确定了

2.3单继承的虚函数表

来看下面的类：

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a = 1;
};

class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
private:
	int b = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

在这里插入图片描述
我们发现Derive少了两个虚表指针，它只有重写的func1和继承的func2，没有func3，func4，这里是监视窗口的问题

在 Derive 类的虚表中，会有以下指向虚函数的指针：

  1. 指向 Derive::func1 的指针 （重写了 Base::func1）
  2. 指向 Base::func2 的指针 （继承自 Base，Derive 没有重写）
  3. 指向 Derive::func3 的指针 （Derive 新增的虚函数）
  4. 指向 Derive::func4 的指针 （Derive 新增的虚函数）

我们通过内存来确认：

在这里插入图片描述
我们不是很确认后面两个地址就是func3和func4的地址

那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数

这里我们用到函数指针数组来实现：

虚函数表的本质就是函数指针数组

void(*p[10])();

这个就定义了一个函数指针数组，我们用typedef来进行优化一下：

typedef void(*VFPTR)();
VFPTR p2[10];

我们定义一个打印虚表的函数

void PrintVFT(VFPTR* vft)
{
	for (size_t i = 0; i < 4; i++)
	{
		printf("%p->", vft[i]);

		VFPTR pf = vft[i];
		(*pf)();
		//pf();
	}
}

依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数

函数写好后，关键是我如何取到它的地址？

Derive d;
int ptr = (int)d;

上面是不支持转换的，只有有关联的类型才能互相转换

但是，指针可以随意转换

VFPTR* ptr = (VFPTR*)(*((int*)&d));
  1. &d 取得 d 对象的地址。
  2. (int*)&d 将 d 对象的地址转换为 int* 类型的指针。这里假定 int 大小足够存储指针
  3. *((int*)&d) 对转换后的指针进行解引用，得到的是 d 对象内存起始处的值。由于在C++中，一个包含虚函数的对象在内存起始地址处通常存储着指向虚表的指针，因此这步操作实际上获取的是指向 Derive 虚表的指针
  4. (VFPTR*) 将 int 类型的值强制转换为 VFPTR* 类型，也就是指向函数指针的指针。
  5. 最终，ptr 就是指向 Derive 类的虚表的指针。

因此，VFPTR* ptr 就是指向目标对象 d 的虚表的指针。之后调用 PrintVFT(ptr); 就可以遍历虚表中的每个条目并调用对应的函数（这里的函数都是通过函数指针 VFPTR 调用的）

在这里插入图片描述

3.抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承

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

在这里插入图片描述
某种意义上说，抽象类强制派生类去完成重写

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

3.1接口继承与实现继承

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

3.2静态多态与动态多态

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态

3.3例题

下面函数输出结果是什么？

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: 以上都不正确

正确答案是B

类 B 继承自类 A 并且 复写了 A 中的虚函数 func。

首先，复写（覆盖）的本质是派生类提供基类虚函数的一个新的实现。基类中的虚函数定义了一个接口，而派生类通过覆盖这个虚函数，提供了这个接口的特定实现

当创建了派生类 B 的实例，并通过它调用 test() 时，过程如下：

  1. test() 是在基类 A 中定义的，因此它会调用 func 时使用 A 中定义的默认参数，即 1。
  2. 由于 func 是虚函数，并且我们实际上是在操作 B 类的对象，因此调用的是 B 类中覆盖的 func 版本。
  3. 被调用的 B 类的 func 输出 “B->”，然后使用传递给它的参数值，此时是基类的默认参数值 1。

综上所述，输出是 B->1。

要明白一个重要的细节：虚函数的默认参数是静态绑定的，而非动态绑定。也就是说，虚函数的默认参数会在编译时根据函数的静态类型决定，而函数的动态类型会决定在运行时实际调用哪个版本的覆盖函数。这意味着即使 B::func 定义了一个默认值 0，在 A::test 中调用 func() 时，由于它在编译时是视为 A 类型的函数调用，所以使用的是 A::func 定义的默认参数 1。这就是为什么是 B->1 而不是 B->0

4.多继承中的虚函数表

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;
};

在这里插入图片描述
这里有两个虚表指针，继承了两个父类，两个父类的虚表不能合在一起，这里对两张虚表都进行了重写，那么这里func3放在哪个虚表中了呢，是都放呢还是只放一个呢？

我们可以用上面的打印虚表的函数进行打印

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;
}
void test()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
}

这里第一个虚表已经讲过，找第二个虚表先强转为char，再进行字节相加*
在这里插入图片描述

func3放入第一个虚表中
在这里插入图片描述

4.1菱形继承和菱形虚拟继承

class A
{
public:
	virtual void func1() { cout << "A::func1" << endl; }
	int _a;
};
class B : public A
//class B : virtual public A
{
public:
	virtual void func2() { cout << "B::func2" << endl; }
	int _b;
};

class C : public A
//class C : virtual public A
{
public:
	virtual void func3() { cout << "C::func3" << endl; }
	int _c;
};

class D : public B, public C
{
public:
	virtual void func4() { cout << "D::func4" << endl; }
	int _d;
};

int main()
{
	D d;
	cout << sizeof(d) << endl;	
	return 0;
}

在这里插入图片描述
在这里插入图片描述
菱形继承与多继承相似，d里面的虚函数放在B的虚表中

4.2菱形虚拟继承：

class B : virtual public A
class C : virtual public A

在这里插入图片描述
在这里插入图片描述
这里除了虚表指针，还有上篇文章讲解的存储偏移量的虚基表指针

int main()
{
	D d;
	cout << sizeof(d) << endl;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

在这里插入图片描述
在这里插入图片描述
菱形虚拟继承，每个类都有一个虚函数，这里ABC都有自己的虚表，但是BC的虚函数不能放在A的虚表中，因为这里虚基类A是共享的

子类有虚函数，继承的父类有虚函数就有虚表，子类对象中就不需要单独建立虚表

在这里插入图片描述
但是菱形虚拟继承就需要自己建立虚表，不能往父类中放

在这里插入图片描述

再看下面的代码：

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

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

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

class D :public B, public C
{
public:
	D(const char* s1, const char* s2, const char* s3, const char* s4)
		:B(s1, s2)  //A  B
		, C(s1, s3)  //A  C
		, A(s1)      //A
	{
		// D
		cout << s4 << endl;
	}
};
int main() {
	D* p = new D("class A", "class B", "class C", "class D");
	delete p;

	return 0;
}

当创建一个派生类的对象时，构造函数会按照特定的顺序执行，确保所有的基类和成员变量都被正确初始化。在多继承和虚继承的情况下，这个顺序变得更加复杂。上面代码涉及到虚继承，这意味着基类 A 只会有一个实例，即使它被多次包含在派生类层次结构中，在 B 和 C 中

D(const char* s1, const char* s2, const char* s3, const char* s4)
		:B(s1, s2)  //A  B
		, C(s1, s3)  //A  C
		, A(s1)      //A
	{

D 的构造函数，我们发现它首先调用 B 的构造函数，然后是 C 的构造函数，最后调用 A 的构造函数。然而，在虚继承的情况下，共享的基类（在该例子中是 A）只会被初始化一次，而且是由最底层的派生类（D）来初始化。无论 B 和 C 在其构造函数中怎么尝试初始化 A，它们的尝试都会被忽略

根据上述规则，执行 new D("class A", "class B", "class C", "class D"); 的过程如下：

  1. 首先，最底层的派生类 D 的构造器被调用。
  2. 因为 A 是通过虚继承被 B 和 C 继承的，所以 D 的构造器负责初始化 A。这里将输出 “class A”
  3. 接下来，D 的构造器调用 B 的构造函数。虽然 B 试图先调用 A 的构造函数，但这个调用会被忽略，因为 A 已经被初始化了。然后，B 的构造器继续执行并输出 “class B”
  4. C 的构造函数也会被调用，但同样，其对 A 构造函数的调用被忽略，并且 C 的构造器继续执行，输出 “class C”
  5. 最后，在 D 的构造函数中的代码执行之前，所有基类都已经初始化完成。最后输出 “class D”。
class A
class B
class C
class D

所以，尽量不要写菱形虚拟继承，坑点十分多

5.虚表的存储位置

我们可以通过下面的代码来推断虚表在哪存储的：

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

class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void tese()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";
	printf("栈:%p\n", &i);
	printf("静态区:%p\n", &j);
	printf("堆:%p\n", p1);
	printf("常量区:%p\n", p2);

	Person p;
	Student s;
	Person* p3 = &p;
	Student* p4 = &s;
	
	printf("Person虚表地址:%p\n", *(int*)p3);
	printf("Student虚表地址:%p\n", *(int*)p4);
}

在这里插入图片描述
可以推断出存储位置在常量区

本节内容到此结束！！感谢大家阅读！！

QuiteCoder
关注
  • 188
    点赞
  • 踩
  • 156
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 254
    评论
专栏目录
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
c++多态及虚函数表内部原理实战详解
bitcarmanlee的博客
05-17 3561
1.多态实现方式 c++的多态机制主要是靠虚函数来实现。具体来说，就是用父类的指针指向子类的实例，然后通过父类指针调用子类对象中的成员函数。这样，就实现了父类指针的“多态"。 想了解虚函数实现机制，就必须先了解对象的存储方式。 2.类的存储方式 我们以为的存储方式是这样： 上面的图，表示对象的数据和函数代码都要分配内存空间，这样内存的利用效率显然较低，因此实际上存储方式是这样： 每个对象占用存储空间的只是该对象的数据部分（虚函数指针和虚基类指针也属于数据部分），函数代码属于公用部分。我们常说的“A对象的成
C++多态之虚函数表深度剖析
大隐隐于野
11-26 236
一、概述 为了实现 C++ 的多态，C++ 使用了一种动态绑定的技术。这个技术的核心是虚函数表（下文简称虚表）。本文介绍虚函数表是如何实现动态绑定的。 二、类的虚表 每个包含了虚函数的类都包含一个虚表。 我们知道，当一个类（A）继承另一个类（B）时，类 A 会继承类 B 的函数的调用权。所以如果一个基类包含了虚函数，那么其继承类也可调用这些虚函数，换句话说，一个类继承了包含虚函数的基类，那么这个类也拥有自己的虚表。 我们来看以下的代码。类 A 包含虚函数vfunc1，vfunc2，由于类 A 包含虚
C++程序设计——多态：虚函数、抽象类、虚函数表
m0_63020222的博客
02-10 1015
C++的多态实现
C++中多态的实现原理：虚函数表与虚函数指针
qq_38410911的博客
09-07 1709
1-多态 多态的实现效果：多态实现了同样的调用语句具有不同的表现形态。 多态成立的三个条件：继承、徐函数重写、父类指针指向子类对象。 多态的C++实现方法：virtual关键字，告诉编译器要执行多态；不要根据指针类型来判断如何调用对应的函数，而是要根据指针所实际指向的对象的类型来判断如何调用。 多态的理论基础：动态联编（if、switch、多态）、静态联编、根据指针实际指向的对象的类型来判...
C++多态：静态多态（函数地址早绑定），动态多态（函数地址晚绑定）虚函数表，虚析构函数重写。
qq_51004011的博客
07-11 1531
只要类中存在修函数或纯虚函数，那么类内就会自动生成一个虚函数表指针，指向一张虚函数表，在这个虚函数表中，存放着类内所有虚函数的地址。当这个类被它的子类继承时，子类也会继承这个虚函数表指针，与虚函数表，（注意两张虚函数表不是同一张表，可以理解为复制了一张虚函数表交给子类的虚函数标配指针。） 现在只要子类中对父类的虚函数和纯虚函数进行函数重写，那么子类中重写后的函数地址就会将原来的函数地址覆盖掉。这样就实现了动态的多态。.........
C++ 面向对象（二）多态 ： 虚函数、多态原理、抽象类、虚函数表、继承与虚函数表
凌桓丶的博客
06-12 1119
目录多态多态的概念多态的构成条件虚函数虚函数的重写协变（返回值不同）析构函数的重写（函数名不同）final和overridefinaloverride抽象类多态的原理 多态 多态的概念 什么是多态呢？就是一种事物，多种形态。就是对于同一个行为，不同的对象去完成就会产生不同的结果。 举个生活中的例子，当你去旅游景点游玩时，不同的身份买票的价格也不一样。比如对于普通人是原价购买，而对于学生和孩子则是半价购买，对于军人则是优先购买。明明同样是购买，不同身份带来的不同结果，就是多态的作用。 在C++中，多态就是对
C++多态之虚函数表详解及代码示例
weixin_46935110的博客
10-29 2212
C++多态之虚函数表详解及代码示例
C++多态：虚函数、指针、虚函数表
deyuzhi的专栏
07-24 874
C++多态：虚函数、指针、虚函数表
C++中的多态——理解虚函数表及多态实现原理
qq_44631587的博客
09-09 1331
多态的概念，构成条件；虚函数的重写，重写的定义，重写的特殊情况，override和final关键字，区分重写、重载、重定义，抽象类的概念；多态的实现原理，父类对象模型，生成默认构造方法的场景，子类对象模型，多态的调用原理，多继承的虚函数表；继承与多态中的常见问题
C++ 多态 虚函数 虚函数表 最是详细
10-01
高质量的C++多态讲解，详细讲解虚函数，虚函数表，虚函数继承，虚函数继承下的内存分配等
深入解析C++中的虚函数与多态
01-21
对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）和一个指向虚函数表的指针（vptr）来实现的。虚函数表，简称为vtbl，虚函数表表对实现多态起着至关重要
c++语言中虚函数实现多态的原理详解
12-25
c++中虚函数表的作用主要是实现了多态的机制。首先先解释一下多态的概念，多态是c++的特点之一，关于多态，简而言之就是 用父类的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数，这种方法呢，...
C++虚函数表实例分析
01-21
多态是C++面向对象程序设计的一个重要特性。以前看到虚函数觉得很神奇，为...当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定的偏移，这样运行期多态便实现了。 在深度《深度》这本书中
C语言——函数指针与指针函数
qq_67319052的博客
05-19 607
函数指针与指针函数有什么区别？
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 632
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
YOLOv8+PyQt：实时检测（摄像头、视频）
最新发布
qq_45445740的博客
05-19 168
【代码】YOLOv8+PyQt：实时检测（摄像头、视频）
【C++风云录】打破边界：心理学与情绪识别
记录我的学习历程
05-16 708
本文主要探讨了六种开发软件工具包，包括但不限于面部表情分析、心理学实验设计、图像处理、数据挖掘、情绪识别以及生物识别技术等各类关键功能，同时也涵盖了其在各自领域的应用。
c++继承、多态和虚函数
07-28
C++中的继承、多态和虚函数是面向对象编程的重要概念。 继承是指一个类可以从另一个类继承属性和方法。子类可以继承父类的公有成员和保护成员，但不能继承私有成员。通过继承，子类可以重用父类的代码，并且可以添加自己的特定功能。继承可以实现代码的重用和层次化的设计。 多态是指同一个函数可以根据不同的对象调用不同的实现。多态可以通过虚函数来实现。虚函数是在基类中声明为虚拟的函数，它可以在派生类中被重写。当通过基类指针或引用调用虚函数时，实际调用的是派生类中的实现。这样可以实现动态绑定，即在运行时确定调用的函数。 虚函数的原理是通过虚函数表来实现的。每个包含虚函数的类都有一个虚函数表，其中存储了虚函数的地址。当调用虚函数时，编译器会根据对象的类型在虚函数表中查找对应的函数地址并调用。 综上所述，C++中的继承、多态和虚函数是实现面向对象编程的重要机制，它们可以提高代码的灵活性和可扩展性。 #### 引用[.reference_title] - *1* *3* [C++多态之 虚函数和虚函数表](https://blog.csdn.net/weixin_46053588/article/details/121231465)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [c++多态及虚函数表内部原理实战详解](https://blog.csdn.net/bitcarmanlee/article/details/124830241)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

QuiteCoder

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值