多态的底层实现原理

最新推荐文章于 2024-04-23 01:37:58 发布
最新推荐文章于 2024-04-23 01:37:58 发布
阅读量234 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69229579/article/details/130434471
版权
文章详细介绍了C++中多态的概念，通过虚函数实现，包括虚函数的声明、重写以及特殊情况如协变和析构函数的重写。多态的构成条件是继承关系和虚函数调用，并通过实例展示了虚函数表的工作原理。同时，文章讨论了单继承、多继承和棱形继承中的虚函数覆盖问题，以及虚拟继承在解决数据冗余和函数覆盖冲突中的作用。
摘要由CSDN通过智能技术生成

文章目录

多态的概念

  多态，通俗点来说，就是多种形态，当不同的对象要去完成某个行为时，会出现不同的状态。
  C++中多态的机制是通过虚函数来实现的。关于多态的实现，就是利用父类类型的指针指向其子类的实例，然后通过父类型的指针调用实际子类的成员函数。
  这种技术可以让父类的成员函数拥有多种形态。C++中存在两种多态，一种为静态多态，一种为动态多态。静态多态试图做到编译时绑定/决议，动态多态试图做到运行时绑定/决议。

虚函数

在类中，被virtual修饰的成员函数就叫做虚函数。

class Base 
{
public:
	virtual void func() { cout << "Base::func()" << endl; } //虚函数
};

虚函数的重写

  子类中存在与父类完全相同的虚函数（函数名，函数返回值，函数参数都相同），就称子类的成员函数完成了对父类成员函数的重写。

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

class Derive : public Base
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void func2() { cout << "Derive::func2()" << endl; }
};

  上述代码中，子类的func1完成了对父类func1的重写，因为子类的func1与父类的func1完全相同；但子类的func2并没有完成对父类func2的重写，因为二者函数参数不同。

多态的构成条件

多态存在于继承关系的父子类中，并且还有两个关键条件：

  1. 必须通过父类的指针/引用调用虚函数。
  2. 被调用的函数必须是虚函数，且子类的虚函数必须完成对父类虚函数的重写。
class Base
{
public:
	virtual void func1() { cout << "Base::func1()" << endl; }
	virtual void func2() { cout << "Base::func2()" << endl; }
};

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

int main()
{
	Base* ptr = new Derive;
	ptr->func1();
	ptr->func2();
	delete ptr;

	return 0;
}

  上述代码中，子类的func1完成了对父类func1的重写，但func2没有；所以，当父类指针调用func1时，能够实现多态。但调用func2时就只是普通调用。如果子类没有完成重写，那么用父类指针的调用都只是普通调用，也就意味着只会调用父类的同名函数。

普通调用与多态调用的区别：

  • 普通调用：跟调用对象的类型有关。
  • 多态调用：跟指针/引用 所指向的对象有关。

虚函数重写的两个例外

协变

  要完成虚函数重写，不一定要满足三同（函数名，返回值，参数）。其中，返回值可以不同，但必须是子类或父类的指针/引用。子类虚函数就返回子类对象的指针/引用，父类就返回父类对象的指针/引用，这种重写形式被称为协变。

class Base
{
public:
	virtual Base* func1() { cout << "Base::func1()" << endl; return this; }
};

class Derive : public Base
{
public:
	virtual Derive* func1() { cout << "Derive::func1()" << endl; return this; }
};

  返回值所指的指针或引用不一定得是当前类对象的指针或引用，但必须满足子类对应子类，父类对应父类的关系。

class A
{
	int _a;
};

class B : public A
{
	int _b;
};

class Base
{
public:
	virtual A* func1() { cout << "Base::func1()" << endl; return nullptr;  }
};

class Derive : public Base
{
public:
	virtual B* func1() { cout << "Derive::func1()" << endl; return nullptr; }
};

析构函数的重写

  如果父类的析构函数为虚函数，那么只要子类的析构函数显示定义，无论是否加了virtual，都会与父类的析构函数构成重写，虽然二者的析构函数名不同。因为编译器底层对析构函数的名字做了特殊处理，编译后析构函数的函数名统一处理成了destructor。

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

class Derive : public Base
{
public:
	~Derive() { cout << "~Derive()" << endl; }
};

析构函数重写的作用

假设有如下代码，

//析构函数的重写
class Base
{
public:
	virtual void func1() { cout << "Base::func1()" << endl; }
	~Base() { cout << "~Base()" << endl; }
private:
	int _a = 1;
};

class Derive : public Base
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	~Derive() 
	{
		delete[] p;
		cout << "~Derive()" << endl; 
	}
private:
	int* p = new int[10];
};


int main()
{
	//用父类指针指向子类，多态的前提条件之一
	Base* ptr = new Derive;
	//多态的调用
	ptr->func1();
	//希望析构Derive对象
	delete ptr;

	return 0;
}

  Derive是Base类的子类，它有一块在堆上的空间。上述代码希望通过多态调用子类的func1，并且在析构的时候能够调用Derive的析构。
但很可惜，上面代码的执行结果是不满足要求的。下面是代码的运行结果，

Derive::func1()
~Base()

  为什么只调用了父类的析构函数，而没有子类的析构函数呢？
  原因很简单，虽然ptr->func1()是多态调用，但delete ptr却只是普通调用。调用delete会有两个行为:1.调用ptr类型的析构函数；2.析构ptr所指向的空间；由于ptr的类型是父类类型，所以只会调用父类的析构函数。
  如果希望上述的析构能够正确执行，那么就需要实现析构函数的多态。

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

class Derive : public Base
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual ~Derive()
	{
		delete[] p;
		cout << "~Derive()" << endl;
	}
private:
	int* p = new int[10];
};


int main()
{
	//用父类指针指向子类，多态的前提条件之一
	Base* ptr = new Derive;
	//多态的调用
	ptr->func1();
	//ptr->~destructor() 多态调用
	delete ptr;

	return 0;
}

运行结果如下，

Derive::func1()
~Derive()
~Base()

虚函数表

  C++的多态机制就是通过虚函数来实现的，而虚函数就是通过一张虚函数表（Virtual Table）来实现的。这个表中，主要存放一个类中的虚函数的地址，通过这张表来解决多态中的重写/覆盖的问题。其本质就是一个函数指针数组。当我们用父类的指针操作一个子类的成员函数时，这张表就像一张地图，指明了实际应该调用的函数。
  C++编译器保证虚函数表的指针存放在了每个对象的最前面的位置。所以我们可以通过对象的地址来获取这张表，然后对其依次遍历，并调用其中的函数。

class Base
{
public:
	virtual void func1() { cout << "Base::func1()" << endl; }
	virtual void func2() { cout << "Base::func2()" << endl; }
};

typedef void(*Vfptr)(); //类型重定义
void PrintVTable(Vfptr* ptr)
{
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("[%d]->%p:", i, ptr[i]);
		ptr[i](); //调用虚函数表中的所指向的函数
	}
}

int main()
{
	Base b;
	Vfptr* ptr = (Vfptr*)*(void**)&b;
	PrintVTable(ptr);

	return 0;
}

  上述代码中，我们先强行把&b转成void** 再解引用（转成void**可以避免32位与64位下地址大小的差异），取得虚函数表指针。由于此时地址还是void*，所以再将void的地址转换成Vfptr。在PrintVTable中，我们再根据虚函数表指针来依次调用虚函数表中的函数。
运行结果如下：

[0]->0x400998:Base::func1()
[1]->0x4009c2:Base::func2()

下面是Base的逻辑结构图：
在这里插入图片描述

  在虚函数表中的最后一个节点，我用nullptr来表示结束节点，这个结束节点标志在不同的编译器下是不一样的，所以前面的代码中打印虚函数表的函数并不具有可移植性。但这并不是重要的问题，不会影响本章内容，所以这里不做修改。
  下面将依次对单继承，多继承，棱形继承中的覆盖问题进行剖析。

单继承（无虚函数覆盖）

假设存在如下的继承关系，

其中子类没有重写任何父类的成员函数。那么其子类的虚函数表的逻辑结构图如下所示，


用代码证明：

class Base
{
public:
	virtual void bfunc1() { cout << "Base::bfunc1()" << endl; }
	virtual void bfunc2() { cout << "Base::bfunc2()" << endl; }
};

class Derive : public Base
{
public:
	virtual void dfunc1() { cout << "Derive::dfunc1()" << endl; }
	virtual void dfunc2() { cout << "Derive::dfunc2()" << endl; }
};

typedef void(*Vfptr)(); //类型重定义
void PrintVTable(Vfptr* ptr)
{
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("[%d]->%p:", i, ptr[i]);
		ptr[i](); //调用虚函数表中的所指向的函数
	}
}

int main()
{
	Derive d;
	Vfptr* ptr = (Vfptr*)*(void**)&d;
	cout << "Base切片中的虚函数表如下:" << endl;
	PrintVTable(ptr);

	return 0;
}

运行结果如下：

Base切片中的虚函数表如下:
[0]->0x4009f8:Base::bfunc1()
[1]->0x400a22:Base::bfunc2()
[2]->0x400a4c:Derive::dfunc1()
[3]->0x400a76:Derive::dfunc2()

通过示例，我们可以看到以下几点：

  1. 虚函数地址按照声明顺序放于表中。
  2. 虚函数表指针位于父类的切片当中。
  3. 父类的虚函数在子类虚函数的前头。

单继承（有虚函数覆盖）

如果没有虚函数覆盖，虚函数将毫无意义。假设存在下面的继承关系，


其中，子类重写了父类的func1()。子类的虚函数表将会是如下形式：
在这里插入图片描述


用代码证明：

class Base
{
public:
	virtual void func1() { cout << "Base::func1()" << endl; }
	virtual void bfunc2() { cout << "Base::bfunc2()" << endl; }
};

class Derive : public Base
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void dfunc2() { cout << "Derive::dfunc2()" << endl; }
};


typedef void(*Vfptr)(); //类型重定义
void PrintVTable(Vfptr* ptr)
{
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("[%d]->%p:", i, ptr[i]);
		ptr[i](); //调用虚函数表中的所指向的函数
	}
	cout << endl;
}

int main()
{
	Derive d;
	Vfptr* ptr = (Vfptr*)*(void**)&d;
	cout << "Base切片中虚函数表如下:" << endl;
	PrintVTable(ptr);

	return 0;
}

运行结果如下：

Base切片中虚函数表如下:
[0]->0x400a32:Derive::func1()
[1]->0x400a08:Base::bfunc2()
[2]->0x400a5c:Derive::dfunc2()

从示例中，我们可以看到以下几点：

  1. 重写的虚函数被覆盖到原本父类同名函数的位置上。
  2. 没有重写的虚函数依旧。

所以，我们也能对下面的调用做出合理的分析了，

Base* ptr = new Derive;
ptr->func1();
delete ptr;

其运行结果为：Derive::func1()

由ptr所指向的父类切片中的虚函数表的Base::func1()已经被子类中的Derive::func1()所取代，所以当我们用ptr调用时，实际上是Derive::func1()被调用。这就是多态的实现原理。
多态实现原理：使用父类指针或引用在父类的切片中寻找虚函数表指针，依靠这个指针寻到虚函数表，并查找虚函数表，调用函数名相同的函数。

多继承（无虚函数覆盖）

假设有如下继承关系，
在这里插入图片描述

其中Derive继承了Base1和Base2，并且没有完成重写。子类的虚函数表逻辑结构图如下，

在这里插入图片描述
代码证明：

typedef void(*Vfptr)(void); //类型重定义
void PrintVTable(Vfptr* ptr)
{
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("[%d]->%p:", i, ptr[i]);
		ptr[i](); //调用虚函数表中的所指向的函数
	}
	cout << endl;
}

class Base1
{
public:
	virtual void b1func1() { cout << "Base1::b1func1()" << endl; }
	virtual void b1func2() { cout << "Base1::b1func2()" << endl; }
	virtual void b1func3() { cout << "Base1::b1func3()" << endl; }
};

class Base2
{
public:
	virtual void b2func1() { cout << "Base2::b2func1()" << endl; }
	virtual void b2func2() { cout << "Base2::b2func2()" << endl; }
	virtual void b2func3() { cout << "Base2::b2func3()" << endl; }
};

class Derive : public Base1, public Base2
{
public:
	virtual void d1func1() { cout << "Derive::d1func1()" << endl; }
	virtual void d1func2() { cout << "Derive::d1func2()" << endl; }
};

int main()
{
	Derive d;
	Base1* ptr1 = &d; 
	PrintVTable((Vfptr*)*(void**)ptr1);
	cout << "Base1切片的虚函数表如下:" << endl;
	Base2* ptr2 = &d;
	cout << "Base2切片的虚函数表如下:" << endl;
	PrintVTable((Vfptr*)*(void**)ptr2);

	return 0;
}

运行结果：

Base1切片的虚函数表如下:
[0]->00FD14B0:Base1::func1()
[1]->00FD14C4:Base1::b1func2()
[2]->00FD14B5:Base1::f1func3()
[3]->00FD1537:Derive::d1func1()
[4]->00FD153C:Derive::d1func2()

Base2切片的虚函数表如下:
[0]->00FD14BF:Base2::b2func1()
[1]->00FD14AB:Base2::b2func2()
[2]->00FD14CE:Base2::b2func3()

通过示例，可以发现以下几点：

  1. 在多继承中，子类的虚函数地址放在第一个继承的父类的虚表中。
  2. 每个父类切片单独维护一张虚表。

多继承（有虚函数覆盖）

假设有如下继承关系，
在这里插入图片描述

子类Derive继承自Base1和Base2，并且完成了对Base1::func1()和Base2::func1()的重写，则Derive的虚表逻辑结构图如下，

在这里插入图片描述
代码证明，

typedef void(*Vfptr)(void); //类型重定义
void PrintVTable(Vfptr* ptr)
{
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("[%d]->%p:", i, ptr[i]);
		ptr[i](); //调用虚函数表中的所指向的函数
	}
	cout << endl;
}

class Base1
{
public:
	virtual void func1() { cout << "Base1::func1()" << endl; }
	virtual void b1func2() { cout << "Base1::b1func2()" << endl; }
	virtual void b1func3() { cout << "Base1::b1func3()" << endl; }
};

class Base2
{
public:
	virtual void func1() { cout << "Base2::func1()" << endl; }
	virtual void b2func2() { cout << "Base2::b2func2()" << endl; }
	virtual void b2func3() { cout << "Base2::b2func3()" << endl; }
};


class Derive : public Base1, public Base2
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void d1func2() { cout << "Derive::d1func2()" << endl; }
};

int main()
{
	Derive d;
	Base1* ptr1 = &d;
	cout << "Base1切片的虚函数表如下:" << endl;
	PrintVTable((Vfptr*)*(void**)ptr1);
	Base2* ptr2 = &d;
	cout << "Base2切片的虚函数表如下:" << endl;
	PrintVTable((Vfptr*)*(void**)ptr2);

	return 0;
}

运行结果：

Base1切片的虚函数表如下:
[0]->0010155A:Derive::func1()
[1]->001014C4:Base1::b1func2()
[2]->001014B5:Base1::b1func3()
[3]->0010153C:Derive::d1func2()

Base2切片的虚函数表如下:
[0]->00101550:Derive::func1()
[1]->001014AB:Base2::b2func2()
[2]->001014CE:Base2::b2func3()

  从示例中，我们可以看到，凡是父类中被子类重写的成员函数，其父类的切片的虚表都会被子类重写的成员函数的地址进行覆盖。
  所以我们可以用不同父类的指针调用子类重写的成员函数，

Derive d;
Base1* ptr1 = &d;
ptr1->func1();
Base2* ptr2 = &d;
ptr2->func1();

//运行结果:
Derive::func1()
Derive::func1()

棱形继承

假设有如下继承关系，
在这里插入图片描述
  其中Base1和Base2继承自GParent，Derive又继承自Base1和Base2，Derive::func1()完成对Base1::func1()和Base2::func1()的重写。Derive的虚表逻辑结构图如下，
在这里插入图片描述

代码证明，

//棱形继承
typedef void(*Vfptr)(void); //类型重定义
void PrintVTable(Vfptr* ptr)
{
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("[%d]->%p:", i, ptr[i]);
		ptr[i](); //调用虚函数表中的所指向的函数
	}
	cout << endl;
}

class GParent
{
public:
	virtual void gpfunc1() { cout << "GParent::gpfunc1()" << endl; }
	int _gp_a;
};

class Base1 : public GParent
{
public:
	virtual void func1() { cout << "Base1::func1()" << endl; }
	virtual void b1func2() { cout << "Base1::b1func2()" << endl; }
	virtual void b1func3() { cout << "Base1::b1func3()" << endl; }
	int _base_b1;
};

class Base2 : public GParent
{
public:
	virtual void func1() { cout << "Base2::func1()" << endl; }
	virtual void b2func2() { cout << "Base2::b2func2()" << endl; }
	virtual void b2func3() { cout << "Base2::b2func3()" << endl; }
	int _base_b2;
};


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

int main()
{
	Derive* d = new Derive;
	Base1* ptr1 = d;
	cout << "Base1切片中的GParent切片的虚函数表如下:" << endl;
	PrintVTable((Vfptr*)*(void**)ptr1);
	Base2* ptr2 = d;
	cout << "Base2切片中的GParent切片的虚函数表如下:" << endl;
	PrintVTable((Vfptr*)*(void**)ptr2);
	delete d;

	return 0;
}

运行结果，

Base1切片中的GParent切片的虚函数表如下:
[0]->00731087:GParent::gpfunc1()
[1]->00731294:Derive::func1()
[2]->00731410:Base1::b1func2()
[3]->007311B3:Base1::b1func3()
[4]->007313F7:Derive::d1func2()

Base2切片中的GParent切片的虚函数表如下:
[0]->00731087:GParent::gpfunc1()
[1]->007312BC:Derive::func1()
[2]->00731028:Base2::b2func2()
[3]->0073151E:Base2::b2func3()

从示例中，可以看到以下几点：

  1. 当有多重继承时，虚函数表指针存放在祖先的切片中。
  2. 虚函数表中的函数地址按照继承关系及声明顺序依次排列。
  3. 棱形继承会造成数据冗余，虚函数表中有两份gpfunc1的地址，Derive对象有两份_gp_a。

棱形虚拟继承

假设有如下继承关系，
在这里插入图片描述
  Base1和Base2虚继承自GParent，Derive继承自Base1和Base2。Derive::func1()完成对Base1::func1()和Base2::func2()的重写。Derive的逻辑结构图如下，
在这里插入图片描述
代码证明如下，

//棱形虚拟继承多态
typedef void(*Vfptr)(void); //类型重定义
void PrintVTable(Vfptr* ptr)
{
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("[%d]->%p:", i, ptr[i]);
		ptr[i](); //调用虚函数表中的所指向的函数
	}
	cout << endl;
}
class GParent
{
public:
	virtual void gpfunc1() { cout << "GParent::gpfunc1()" << endl; }
	int _gp_a = 10;
};

class Base1 : virtual public GParent
{
public:
	virtual void func1() { cout << "Base1::func1()" << endl; }
	virtual void b1func2() { cout << "Base1::b1func2()" << endl; }
	virtual void b1func3() { cout << "Base1::b1func3()" << endl; }
	int _base_b1 = 20;
};

class Base2 : virtual public GParent
{
public:
	virtual void func1() { cout << "Base2::func1()" << endl; }
	virtual void b2func2() { cout << "Base2::b2func2()" << endl; }
	virtual void b2func3() { cout << "Base2::b2func3()" << endl; }
	int _base_b2 = 30;
};


class Derive : public Base1, public Base2
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void d1func2() { cout << "Derive::d1func2()" << endl; }
	int _d = 40;
};

int main()
{
	Derive d;
	Base1* ptr1 = &d;
	Vfptr* vfptr1 = (Vfptr*)(*(void**)ptr1);
	cout << "Base1切片中的虚函数表如下:" << endl;
	PrintVTable(vfptr1);

	Base2* ptr2 = &d;
	Vfptr* vfptr2 = (Vfptr*)(*(void**)ptr2);
	cout << "Base2切片中的虚函数表如下:" << endl;
	PrintVTable(vfptr2);

	GParent* ptr3 = &d;
	Vfptr* vfptr3 = (Vfptr*)(*(void**)ptr3);
	cout << "GParent切片中的虚函数表如下:" << endl;
	PrintVTable(vfptr3);

	return 0;
}

运行结果如下，

Base1切片中的虚函数表如下:
[0]->00A714B5:Derive::func1()
[1]->00A713AC:Base1::b1func2()
[2]->00A71177:Base1::b1func3()
[3]->00A71393:Derive::d1func2()

Base2切片中的虚函数表如下:
[0]->00A714BA:Derive::func1()
[1]->00A71028:Base2::b2func2()
[2]->00A714A1:Base2::b2func3()

GParent切片中的虚函数表如下:
[0]->00A7107D:GParent::gpfunc1()

从示例中，我们可以得出以下几点：

  1. 使用棱形虚拟继承后，有一块单独的祖父类的切片被放置在了子类的最尾部，该切片存放祖父类的虚函数表指针和其成员变量。

  2. 父类中祖父类的切片改为存放虚函数表指针（该表不再含有祖父类的虚函数地址）和虚基表指针（该表存放着该指针的地址到尾部祖父类切片中成员变量的地址的偏移量）。

几点注意事项：

  1. 在棱形虚拟继承中，我们可以使用GParent来获得Derive对象中尾部的祖父类切片。但是，如果是在棱形继承中，我们无法用GParent来获得祖父类切片，因为祖父类切片只在Base1和Base2中各有一份，编译器无法识别你所要的切片是哪一份。

  2. 在棱形虚拟继承中，如果两个父类都重写了祖父类的虚函数，那么子类也必须重写祖父类的虚函数。因为子类中的祖父类切片中的虚函数表只允许一个虚函数进行覆盖，但Base1和Base2都要对其祖父类的虚函数进行覆盖，编译器无法辨认用哪个父类虚函数地址进行覆盖。在棱形继承中，则不会有这种情况，因为Base1和Base2的切片中各有一张存放着GParent虚函数地址的虚表。

且听风吟-静待花开
关注
专栏目录
详解C++多态的实现及底层原理 - 笔记
杨
09-18 2403
C++中引入了多态的思想，说白了就是拥有多种形态，可以分为静态动态(重载，编译阶段确认函数地址)和动态动态(继承重写基类的虚函数实现的多态，在运行时从虚函数表中寻找调用函数的地址)； 1：用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2：存在虚函数的类都有一个一维的虚函数表叫做虚表，类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 3：多态性是一个接口多种实现，是面向对象的核心，分为类的多态性和函数的多态性。 4：多态用虚函数来.
C++多态及底层实现原理
最新发布
Simona_Wu的博客
08-01 691
前两天去面试，面试官问到多态是如何实现的，以下依次讲解多态基本概念、虚函数表的工作原理，以及利用IDA反编译exe讲解汇编指令来清晰底层实现原理。多态性（Polymorphism）是面向对象编程中的一个重要概念，它允许对象以多种形式存在。C++中的多态性主要通过继承和虚函数来实现。多态性使得一个基类指针或引用能够指向派生类的对象，并调用派生类的成员函数。这样，程序可以在运行时决定调用哪个函数，从而实现动态绑定。
多态的实现原理
热门推荐
Tomcat的Tom
10-20 1万+
0．前言 多态在Java技术里有很重要的地位，在面试中也会经常被问到。 多态的使用大家应该都比较了解，但是多态的实现原理就有点抽象了，查了很多很多资料，连续几天断断续续的看，有时候看着看着就走神了。毕竟太抽象，哈哈~ 不过依然硬着头皮看下来了（也不知道看了多少遍），并且将很多资料里关于多态的知识进行了整理（添添加加删删减减了很久，也把重点根据自己的理解用红字标出），便有了这篇文章。通过这篇文章
C++语言虚函数表实现多态原理(六十七)
Android系统攻城狮
02-25 635
首先介绍一下为什么会引进多态呢，基于c++的复用性和拓展性而言，同类的程序模块进行大量重复，是一件无法容忍的事情，比如我设置了苹果，香蕉，西瓜类，现在想把这些东西都装到碗这个函数里，那么在主函数当中，声明对象是必须的，但是每一次装进碗里对于水果来说，都要用自己的指针调用一次装的功能，那为什么不把这些类抽象成一个水果类呢，直接定义一个水果类的指针一次性调用所有水果装的功能呢，这个就是利用父类指针去调...
【C++ 】多态的底层实现原理
Z1tai的博客
04-20 223
在面向对象编程中，多态是一个核心概念，它允许使用父类类型的指针或引用来引用子类对象，并通过这种方式实现在运行时选择适当的方法。本文将深入探讨多态的底层实现原理，包括虚函数、虚函数表、派生类和虚函数覆盖、多态的运行时行为以及动态绑定与静态绑定。
Java 中多态的实现原理
gyf1314520的博客
11-10 555
Java 中多态的实现原理
Java基础-多态实现原理
子悠のziyou
12-09 1370
多态是面向对象编程里面的概念，一个接口的多种实现不同的实现方式，即为多态这里的接口不应理解得太死板，比如在 Java 里面，继承一个类和实现一个接口本质上都是一种继承行为，因此都可以理解为多态的体现。从静态和动态的角度进行划分，多态可以分为编译时多态和运行时多态。编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法，编译之后会变成两个不同的方法。而运行时多态是动态的，是通过动态绑定来实现的，也就是大家通常所说的多态性，本篇博客主要讨论运行时多态。
Java多态的实现原理概述
Cratels学编程
04-01 218
Java多态的实现原理概述 面向对象的编程语言的特色就是：封装，继承，多态。作为基本特色之一，多态为我们带来了很多的便利。这篇文章我们将从大体上探究一下多态的实现原理，而不做具体实现细节的分析。 java项目是有一个个类组成的，出于重用以及可扩展的考虑，我们经常讲这些类关联起来，比如继承或是实现。多态也是基于类之间的这种关联来实现的，这也是OOP的精华所在。 当一个类被加载到JVM上时，该类的类型信息就被加载到JVM的方法区中。类型信息一般包括该类的方法代码、类变量、成员变量的定义，变量类型信息等等该类
C++——“多态”的底层实现，看了之后保你理解
qq_44745063的博客
05-29 393
作者：小 琛 欢迎转载，请标明出处 什么是多态？ 完成某一行为，不同对象去做，会有不同的效果 多态的条件 必须通过基类的指针或者引用调用虚函数 被调用的函数必须是虚函数，子类继承了父类，且派生类必须对基类的虚函数进行重写 析构函数是否要写成虚函数？ 举例子， ...
详细C++三大特性——多态底层原理
zcxmjw的博客
04-06 1001
上一篇主要讲了多态的基本内容和使用，本篇文章将带领铁子们深入了解多态的底层原理，本文实验比较多，建议铁子们看完可以自己再实验实验，一定会收货颇丰。
Java 多态的底层实现
Lucky小黄人的博客
12-16 490
参考： java多态实现原理 C++ 多态的实现及原理 多态的底层实现 Java是用过方法表来实现的，C++是通过虚表来实现的。 Java 对于方法调用动态绑定的实现主要依赖于方法表，但通过类引用调用和接口引用调用的实现则有所不同。总体而言，当某个方法被调用时，JVM 首先要查找相应的常量池，得到方法的符号引用，并查找调用类的方法表以确定该方法的直接引用，最后才真正调用该方法。 在类被加...
C++：多态的底层实现原理 -- 虚函数表
weixin_43908419的博客
04-14 1511
本文结合内存监视窗口和虚表打印函数，分析了多态实现的底层原理，并给出了单继承和多继承体系中的内存模型。
【C++】详解多态的底层原理
m0_70980326的博客
07-24 1138
详解多态的底层原理，带你理解多态是如何实现的，什么是虚函数表指针、什么是虚函数表、子类的虚函数表如何生成等问题
多态的定义、重写、原理
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
03-11 782
多态的定义、协变、析构函数的重写；关键字final和override；多态的原理和单继承、多继承的虚函数表
【多态】底层原理
m0_68617301的博客
04-23 782
本篇文章主要讲解多态底层原理的相关内容。
浅谈继承与多态
tttjp的博客
04-03 304
学习C++的人都知道面向对象程序设计有4个主要特点：抽象、封装、继承和多态性。可见继承和多态在C++中占据的分量不一般。 本篇文章分别用阐述概念和举栗说明两种方式研究继承与多态，其中会穿插图片说明，望达到轻松理解C++中继承与多态机制的效果。 继承的概念 所谓继承就是在一个已有类的基础上建立一个新的类。以存在的类称为“基类”或“父类”，新建的类称为“派生类“或”子类”。继承机制可提
动态多态的底层实现原理
05-10
动态多态是指在运行时根据对象的实际类型来调用相应的方法，而不是根据对象的静态类型来调用方法。底层实现原理主要涉及到虚函数表和虚函数指针。 当一个类中存在虚函数时，编译器会为该类生成虚函数表（vtable），虚函数表是一个数组，存放着虚函数的地址。每个对象都会有一个指向虚函数表的虚函数指针（vptr），该指针指向当前对象所属的类的虚函数表，由于每个对象所属的类可能不同，所以不同对象的虚函数指针指向的虚函数表也可能不同。 当调用一个虚函数时，编译器会根据对象的虚函数指针找到该对象所属的类的虚函数表，然后根据函数在虚函数表中的位置调用相应的虚函数。这样就实现了动态多态的效果，即在运行时通过对象的实际类型来确定调用哪个函数。 需要注意的是，虚函数调用的开销比普通函数调用要高，因为需要先查找虚函数表，然后再调用相应的函数。但是这种开销相对较小，对于大多数应用来说并不会影响程序的性能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值