C++面向对象---虚函数&继承

已于 2023-07-20 16:32:43 修改
阅读量85 收藏 1
点赞数
分类专栏： 滴水逆向第三期-实践 文章标签： c++
于 2023-07-03 21:03:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tscg_/article/details/130853367
版权

一、单继承无函数覆盖

代码如下：

#include <stdio.h>
struct Base
{
public:
    virtual void Function_1()
    {
        printf("Base:Function_1...\n");
    }
    virtual void Function_2()
    {
        printf("Base:Function_2...\n");
    }
    virtual void Function_3()
    {
        printf("Base:Function_3...\n");
    }
};
struct Sub:Base
{
public:
    virtual void Function_4()
    {
        printf("Sub:Function_4...\n");
    }
    virtual void Function_5()
    {
        printf("Sub:Function_5...\n");
    }
    virtual void Function_6()
    {
        printf("Sub:Function_6...\n");
    }
};
void TestMethod()
{
	//查看 Sub 的虚函数表				
	Sub sub;
	//对象的前四个字节就是虚函数表				
	printf("base的虚函数表地址为：%x\n", *(int*)&sub);
	//通过函数指针调用函数，验证正确性				
	typedef void(*pFunction)(void);
	pFunction pFn;
	for (int i = 0; i < 6; i++)
	{
		int temp = *((int*)(*(int*)&sub) + i);
		pFn = (pFunction)temp;
		pFn();
	}
}
int main()
{
    TestMethod();
    return 0;
}

可以看出，在单继承无函数覆盖的情况下，子类Sub继承父类Base，先调用父类的构造函数，输出顺序正常
在这里插入图片描述

二、单继承有函数覆盖

代码如下：

#include <stdio.h>
struct Base
{
public:
    virtual void Function_1()
    {
        printf("Base:Function_1...\n");
    }
    virtual void Function_2()
    {
        printf("Base:Function_2...\n");
    }
    virtual void Function_3()
    {
        printf("Base:Function_3...\n");
    }
};
struct Sub :Base
{
public:
    virtual void Function_1()
    {
        printf("Sub:Function_1...\n");
    }
    virtual void Function_2()
    {
        printf("Sub:Function_2...\n");
    }
    virtual void Function_6()
    {
        printf("Sub:Function_6...\n");
    }
};
void TestMethod()
{
    //查看 Sub 的虚函数表				
    Sub sub;
    //对象的前四个字节就是虚函数表				
    printf("base的虚函数表地址为：%x\n", *(int*)&sub);
    //通过函数指针调用函数，验证正确性				
    typedef void(*pFunction)(void);
    pFunction pFn;
    for (int i = 0; i < 4; i++)
    {
        int temp = *((int*)(*(int*)&sub) + i);
        pFn = (pFunction)temp;
        pFn();
    }
}
int main()
{
    TestMethod();
    return 0;
}

子类Sub单继承父类Base，且子类覆盖了父类的函数Function_1和Function_2，而发现父类只有未被覆盖的Function_3能够输出，而Function_1和Function_2由于被子类覆盖，所以输出出来的是子类的Function_1和Function_2
在这里插入图片描述

但是子类只有在父类为virtual的时候才会覆盖父类

若将Function_1的virtual删掉，结果为：
在这里插入图片描述
我们可以发现，Function_2、Function_3还有Function_6照常，但是Function_1却是属于Sub类。
也就是说，子类函数只会覆盖父类的相应虚函数。

三、多继承无函数覆盖

#include <stdio.h>
struct Base1
{
public:
	virtual void Fn_1()
	{
		printf("Base1:Fn_1...\n");
	}
	virtual void Fn_2()
	{
		printf("Base1:Fn_2...\n");
	}
};
struct Base2
{
public:
	virtual void Fn_3()
	{
		printf("Base2:Fn_3...\n");
	}
	virtual void Fn_4()
	{
		printf("Base2:Fn_4...\n");
	}
};
struct Sub :Base1, Base2
{
public:
	virtual void Fn_5()
	{
		printf("Sub:Fn_5...\n");
	}
	virtual void Fn_6()
	{
		printf("Sub:Fn_6...\n");
	}
};
int main(int argc, char* argv[])
{
	//查看 Sub 的虚函数表					
	Sub sub;

	//通过函数指针调用函数，验证正确性					
	typedef void(*pFunction)(void);


	//对象的前四个字节是第一个Base1的虚表					
	printf("Sub 的虚函数表地址为：%x\n", *(int*)&sub);

	pFunction pFn;

	for (int i = 0; i < 6; i++)
	{
		int temp = *((int*)(*(int*)&sub) + i);
		if (temp == 0)
		{
			break;
		}
		pFn = (pFunction)temp;
		pFn();
	}

	//对象的第二个四字节是Base2的虚表					
	printf("Sub 的虚函数表地址为：%x\n", *(int*)((int)&sub + 4));

	pFunction pFn1;

	for (int k = 0; k < 2; k++)
	{
		int temp = *((int*)(*(int*)((int)&sub + 4)) + k);
		pFn1 = (pFunction)temp;
		pFn1();
	}
	printf("%x\n", sizeof(Sub));	//因为有两个直接父类，所以有两个虚函数表，总大小为8
	return 0;
}

输出结果为：
在这里插入图片描述

可以看到，打印出来的Sub对象的大小为8，而一个指向虚函数表的地址的大小为4，也就是说，子类有多个直接父类的时候，就会出现对应父类数量的多个虚函数表
在这里插入图片描述
总结起来就是：由于有两个直接父类，所以Sub对象存储了两张虚函数表。第一张虚函数表存储了一个父类Base1的函数以及它的子类Sub的函数，第二张虚函数表存储了第二个父类Base2的函数

四、多继承有函数覆盖

#include <stdio.h>
struct Base1
{
public:
	virtual void Fn_1()
	{
		printf("Base1:Fn_1...\n");
	}
	virtual void Fn_2()
	{
		printf("Base1:Fn_2...\n");
	}
};
struct Base2
{
public:
	virtual void Fn_3()
	{
		printf("Base2:Fn_3...\n");
	}
	virtual void Fn_4()
	{
		printf("Base2:Fn_4...\n");
	}
};
struct Sub :Base1, Base2
{
public:
	virtual void Fn_1()
	{
		printf("Sub:Fn_1...\n");
	}
	virtual void Fn_3()
	{
		printf("Sub:Fn_3...\n");
	}
	virtual void Fn_5()
	{
		printf("Sub:Fn_5...\n");
	}
};
int main(int argc, char* argv[])
{
	//查看 Sub 的虚函数表					
	Sub sub;
	//通过函数指针调用函数，验证正确性					
	typedef void(*pFunction)(void);
	//对象的前四个字节是第一个Base1的虚表					
	printf("Sub 的虚函数表地址为：%x\n", *(int*)&sub);
	pFunction pFn;
	for (int i = 0; i < 6; i++)
	{
		int temp = *((int*)(*(int*)&sub) + i);
		if (temp == 0)
		{
			break;
		}
		pFn = (pFunction)temp;
		pFn();
	}
	//对象的第二个四字节是Base2的虚表					
	printf("Sub 的虚函数表地址为：%x\n", *(int*)((int)&sub + 4));
	pFunction pFn1;
	for (int k = 0; k < 2; k++)
	{
		int temp = *((int*)(*(int*)((int)&sub + 4)) + k);
		pFn1 = (pFunction)temp;
		pFn1();
	}
	return 0;
}

在这里插入图片描述
首先遍历第一张虚函数表，由于子类覆盖，所以先输出被子类覆盖的Fn_1，然后顺序输出父类的Fn_2，最后输出子类的Fn_5
然后遍历第二章虚函数表，先输出被子类覆盖的Fn_3，然后输出父类的Fn_4

五、多重继承无函数覆盖

#include <stdio.h>
struct Base1
{
public:
	virtual void Fn_1()
	{
		printf("Base1:Fn_1...\n");
	}
	virtual void Fn_2()
	{
		printf("Base1:Fn_2...\n");
	}
};
struct Base2 :Base1
{
public:
	virtual void Fn_3()
	{
		printf("Base2:Fn_3...\n");
	}
	virtual void Fn_4()
	{
		printf("Base2:Fn_4...\n");
	}
};
struct Sub :Base2
{
public:
	virtual void Fn_5()
	{
		printf("Sub:Fn_5...\n");
	}
	virtual void Fn_6()
	{
		printf("Sub:Fn_6...\n");
	}
};
int main(int argc, char* argv[])
{
	//查看 Sub 的虚函数表					
	Sub sub;
	//观察大小：虚函数表只有一个					
	printf("%x\n", sizeof(sub));
	//通过函数指针调用函数，验证正确性					
	typedef void(*pFunction)(void);
	//对象的前四个字节是就是虚函数表					
	printf("Sub 的虚函数表地址为：%x\n", *(int*)&sub);
	pFunction pFn;
	for (int i = 0; i < 6; i++)
	{
		int temp = *((int*)(*(int*)&sub) + i);
		if (temp == 0)
		{
			break;
		}
		pFn = (pFunction)temp;
		pFn();
	}
	return 0;
}

在这里插入图片描述
多重继承无函数覆盖，先输出基类的函数，然后一代一代往下找，最后才输出到最后一个子类的函数

六、多重继承有函数覆盖

#include <stdio.h>
struct Base1
{
public:
	virtual void Fn_1()
	{
		printf("Base1:Fn_1...\n");
	}
	virtual void Fn_2()
	{
		printf("Base1:Fn_2...\n");
	}
};
struct Base2 :Base1
{
public:
	virtual void Fn_3()
	{
		printf("Base2:Fn_3...\n");
	}
};
struct Sub :Base2
{
public:
	virtual void Fn_1()
	{
		printf("Sub:Fn_1...\n");
	}
	virtual void Fn_3()
	{
		printf("Sub:Fn_3...\n");
	}
};
int main(int argc, char* argv[])
{
	//查看 Sub 的虚函数表				
	Sub sub;
	//观察大小：虚函数表只有一个				
	printf("%x\n", sizeof(sub));
	//通过函数指针调用函数，验证正确性				
	typedef void(*pFunction)(void);
	//对象的前四个字节是就是虚函数表				
	printf("Sub 的虚函数表地址为：%x\n", *(int*)&sub);
	pFunction pFn;
	for (int i = 0; i < 6; i++)
	{
		int temp = *((int*)(*(int*)&sub) + i);
		if (temp == 0)
		{
			break;
		}
		pFn = (pFunction)temp;
		pFn();
	}
	return 0;
}

在这里插入图片描述

本文为参考滴水三期的学习笔记

a11ure_1ove
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象程序设计-C++-试卷分析(与“函数”相关共66张).pptx
11-13
以上就是试卷分析中涉及的C++面向对象程序设计的主要知识点，包括函数模板、数据类型转换、构造与析构、const修饰符的用法、静态成员函数、虚函数、继承与派生，以及封装。这些知识点都是C++程序员必须掌握的基础。
c++类继承详解(二)-虚函数
技术之路
04-01 732
面向对象的主要目的之一是提供可重用的代码。面向对象主要包括封装、继承、多态等特性，在做项目的时候碰到的最多的应该是继承了，但是总是对继承的感觉是模模糊糊的，在上一篇中记录了三种继承，本篇记录一下在继承过程中虚函数的作用以及使用。 虚函数的主要作用是在继承中实现函数的动态绑定，进而形成多态。它可以根据对象的实际类型实现相应的操作。下面根据例子来说明。 基类代码如下： BaseClass....
C++继承&虚函数
Fishmemory的博客
05-26 1447
C++继承的应用和虚函数的概念
C++ 各种继承关系中的虚函数
man_skill的博客
04-02 515
#C++ 各种继承关系中的虚函数探幽 最近在学习C++，卡在了实现多态的虚函数这里，之后通过阅读博文：C++虚函数表解析和自己的一些实践，有了点初步的理解，如果错误，欢迎指正。 首先建立如图所示的继承关系： 代码如下： class A { public: virtual void speak() { cout << "this is A"<<endl; } }; class B { public: virtual void spea
C++继承中虚函数的使用
潘志威
03-30 1万+
一：继承中的指针问题。 1． 指向基类的指针可以指向派生类对象，当基类指针指向派生类对象时，这种指针只能访问派生对象从基类继承 而来的那些成员，不能访问子类特有的元素 ，除非应用强类型转换，例如有基类Ｂ和从Ｂ派生的子类Ｄ，则B *p;D  dd; p=&dd;是可以的，指针p只能访问从基类派生而来的成员，不能访问派生类Ｄ特有的成员．因为基类不 知道派生类中的这些成员。 2．
【C++】继承与虚函数
weixin_43776810的博客
10-08 828
作用派生类的构造与释放派生类和基类之间的转换多态虚函数实现原理
C++面向对象程序设计-学生管理系统
最新发布
03-11
《C++面向对象程序设计-学生管理系统》 在IT领域，C++是一种强大的编程语言，以其面向对象的特性被广泛应用于系统开发，特别是在构建复杂的、性能要求高的应用中。本项目“学生管理系统”就是利用C++的面向对象编程...
完整word版-《C++面向对象程序设计》期末考试试题.doc
11-24
本文将对《C++面向对象程序设计》考试试题进行详细解析，涵盖命名冲突机制、虚函数、虚基类、this 指针、访问权限、类定义、成员函数、静态成员、抽象类、异常处理等多个方面的知识点。 一、单选题 1. C++中解决...
C++面向对象多线程编程-pdf
09-12
在"C++面向对象多线程编程"这一主题中，我们将深入探讨以下几个关键知识点： 1. 面向对象编程（OOP）基础： - 类与对象：类是对象的蓝图，定义了一组属性（数据成员）和行为（成员函数）。对象是类的实例，具有...
面向对象的程序设计-个人复习笔记
10-26
以下是一些关于C++面向对象编程的重要知识点： 1. **类与对象**：类是数据结构和操作这些数据的方法的集合，而对象是类的实例。在C++中，我们使用`class`关键字来定义类，类可以包含数据成员（变量）和成员函数...
【C++】继承、虚函数
Love_cch的博客
07-31 752
我们要清楚继承的应用场景，为什么会引出继承的概念？ 1.要创建的新类与已有的类类似，只是多出几个成员变量或者成员函数 2.当要创建多个类，它们拥有很多类似的成员变量或者成员函数时，可以把这些类共同的成员提取出来，定义一个基类，然后由基类继承。 继承的本质含义就是代码的复用，派生类可以继承除基类构造，析构函数以外其他 所有的成员，为派生类所用，派生类只需要实现自己特有的成员即可 两个...
C++虚继承和虚基类
zzwdkxx的专栏
12-06 1088
多继承（Multiple Inheritance）是指从多个直接基类中产生派生类的能力，多继承的派生类继承了所有父类的成员。尽管概念上非常简单，但是多个基类的相互交织可能会带来错综复杂的设计问题，命名冲突就是不可回避的一个。 多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如典型的是菱形继承，如下图所示： 图1
一篇文章带你学懂C++虚函数表的继承问题
Jacksqh的博客
04-08 4908
虚函数表-继承 单继承 结论：当父类定义了虚函数时，在子类进行继承的时候会将父类的虚函数表也给继承下来所以那一些虚函数在子类中也是virtual类型的，如果要对父类中的虚函数进行重写时或添加虚函数，顺序是：（图表说明为图一) ①先将父类的虚函数列表复制过来（补充一点 ②重写虚函数时是把从父类继承过来的虚函数表中对应的虚函数进行相应的替换。 ③如果子类自己要添加自己的虚函数，则是把添加的虚函数加到从......
C++：继承及虚函数
weixin_43589450的博客
07-19 397
1、继承的形式 派生类：基类{}； 例如：B:A{}; ①派生类 不能直接访问基类的私有成员，必须通过基类方法进行访问（通过A::基类方法()）。引申，所以引入了一个访问控制符protected，这个就是为了派生类直接去访问基类的成员数据，其他情况protected与private完全一样。 ②创建派生类对象时，程序首先穿件基类对象，所以基类对象的构造函数先于派生类调用。 派生类构造函数小结：（1）首先创建类对象；（2）派生类构造函数应通过成员初始化列表将基类信息传递给基类构造函数；例如：A(int a,i
C++ 虚函数与继承
qq_47471199的博客
09-02 2008
百度百科关于虚函数的定义： 简单地说，那些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异，而采用不同的策略。 维基百科对于虚函数的定义： 在面向对象程序设计领域，C++、Object Pascal 等语言中有虚函数（英语：virtual function）或虚方法（英语：virtual method）的概念。这种函数或方法可以被子类继承和覆盖，
c++ 继承 虚函数
deng245044611的专栏
08-27 663
C++中的成员和函数，有静态和非静态。 1、非静态数据成员：放在每一个对象体内，作为对象专有的数据成员。 2、静态数据成员：被提取出来放在程序的静态数据区内，为该类所有对象共享，因此只存在一份。（引申下，一个类模板中的静态数据成员实例化成模板类之后有几份？思考下。） 3、静态和非静态成员函数：最终都被提取出来放在程序的代码中并为该类所有对象共享。因每一个成员函数也只能存在一份代码尸体。在C+
C++中虚继承的作用及底层实现原理
热门推荐
bxw1992的博客
08-30 5万+
虚继承和虚函数是完全无相关的两个概念。 虚继承是解决C++多重继承问题的一种手段，从不同途径继承来的同一基类，会在子类中存在多份拷贝。这将存在两个问题：其一，浪费存储空间；第二，存在二义性问题，通常可以将派生类对象的地址赋值给基类对象，实现的具体方式是，将基类指针指向继承类（继承类有基类的拷贝）中的基类对象的地址，但是多重继承可能存在一个基类的多份拷贝，这就出现了二义性。 虚继承可以解
c++---------虚函数及继承(一)
qq_41983709的博客
01-11 536
1.class的内存布局（无虚函数&继承版） 首先，需要弄清楚一件事情，平时所声明的类只是一种类型定义，它本身是没有大小可言的。 我们这里指的类的大小，其实指的是类的对象所占的大小。因此，如果用sizeof运算符对一个类型名操作，得到的是具有该类型实体的大小。 关于类/对象大小的计算 首先，类大小的计算遵循结构体的对齐原则 类的大小与普通数据成员有关，与成员函数和静态成员无关。即普...
C/C++：类的继承、多态与虚函数、重载
weixin_43793960的博客
05-24 865
面向对象的编程主要目的是提供可重复利用的代码。 类的继承也是代码重用的一种方式。 从已有的类（基类）派生出新的类，（派生类）继承了原有类的特性，同时在其基础上进行扩展增加功能。 1. 继承 · 派生类可以访问基类的公有成员； · 派生类不能直接访问基类的私有成员，必须通过基类的公有函数间接访问私有成员——派生类的构造函数必须使用基类的构造函数； class A { public: void Func1(void); void Func2(void); }; class B : public
C++面向对象程序设计-章-多态性-虚函数(与“函数”有关文档共45张).pptx
11-18
"C++面向对象程序设计中的多态性与虚函数" 在C++编程语言中，面向对象程序设计（OOP）具有四个核心特性：抽象性、封装性、继承性和多态性。多态性（Polymorphism）是OOP的精髓之一，它允许同一名称的函数或操作在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值