一篇文章带你了解C++多态的实现原理

目录
  • 虚函数和多态
  • 多态的作用
  • 多态的一个例子
  • 构造函数和析构函数中存在多态吗?
  • 多态的实现原理
    • 虚函数表
  • 虚析构函数
  • 纯虚函数和抽象类
  • 总结

虚函数和多态

虚函数:

  • 在类的定义中,前面有 virtual 关键字的成员函数称为虚函数
  • virtual 关键字只用在类定义里的函数声明中,写函数体时不用

比如:

class Base
{
    virtual int Fun() ; // 虚函数
};
int Base::Fun() // virtual 字段不用在函数体时定义
{ }
  • 多态的表现形式 派生类的指针」
  • 可以赋给「基类指针」通过基类指针调用基类和派生类中的同名「虚函数」时

1.若该指针指向一个基类的对象,那么被调用是 基类的虚函数;

2.若该指针指向一个派生类的对象,那么被调用 的是派生类的虚函数

#include <iostream>
using namespace std;
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat: public Animal
{
public:
	void speak()
	{
		cout << "猫在叫" << endl;
	}
};
void test01()
{
	Cat cat;
	Animal* p = &cat;//Animal *p=new Cat
	p->speak();//用哪个虚函数取决于 p 指向哪种类型的对象
}
int main()
{
	test01();
}

派生类的对象可以赋给基类「引用」通过基类引用调用基类和派生类中的同名「虚函数」时

1.若该引用引用的是一个基类的对象,那么被调 用是基类的虚函数

2.若该引用引用的是一个派生类的对象,那么被 调用的是派生类的虚函数

比如:

#include <iostream>
using namespace std;
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat: public Animal
{
public:
	void speak()
	{
		cout << "猫在叫" << endl;
	}
};
void test01()
{
	Cat cat;
	Animal& p = cat;
	p.speak();
}
int main()
{
	test01();
}

多态的作用

在面向对象的程序设计中使用「多态」,能够增强程序的可扩充性,即程序需要修改或增加功能的时候,需要改动和增加的代码较少。

多态的一个例子

比如:

class Base
{
public:
    void fun1()
    {
        fun2();
    }
    virtual void fun2()  // 虚函数
    {
        cout << "Base::fun2()" << endl;
    }
};
class Derived : public Base
{
public:
    virtual void fun2()  // 虚函数
    {
        cout << "Derived:fun2()" << endl;
    }
};
int main()
{
    Derived d;
    Base * pBase = & d;
    pBase->fun1();
    return 0;
}

请问输出结果是什么?

我们可能会认为pBase 指针对象虽然指向的是派生类对象,但是派生类里没有 fun1 成员函数,则就调用基类的 fun1 成员函数,Base::fun1() 里又会调用基类的 fun2 成员函数,所以输出结果是Base::fun2()

但结果却是Derived:fun2(),为什么会这样?

我们将代码修改一下

class Base
{
public:
    void fun1()
    {
        this->fun2();  // this是基类指针,fun2是虚函数,所以是多态
    }
}

this指针的作用域是在类内部,当在类的非静态成员函数中访问类的非静态成员的时候,编译器会自动将对象本身的地址作为一个隐含参数传递给函数,其作用就是指向成员函数所作用的对象,所以非静态成员函数中可以直接使用 this 来代表指向该函数作用的对象的指针。

pBase 指针对象指向的是派生类对象,派生类里没有 fun1 成员函数,所以就会调用基类的 fun1 成员函数,在Base::fun1() 成员函数体里执行 this->fun2() 时,实际上指向的是派生类对象的 fun2 成员函数。

所以我们需要注意:

  • 在非构造函数,非析构函数的成员函数中调用「虚函数」,是多态

构造函数和析构函数中存在多态吗?

在构造函数和析构函数中调用「虚函数」,不是多态。编译时即可确定,调用的函数是自己的类或基类中定义的函数,不会等到运行时才决定调用自己的还是派生类的函数。

#include <iostream>
using namespace std;
// 基类
class CFather
{
public:
    virtual void hello() // 虚函数
    {
        cout << "hello from father" << endl;
    }
    virtual void bye() // 虚函数
    {
        cout << "bye from father" << endl;
    }
};
// 派生类
class CSon : public CFather
{
public:
    CSon() // 构造函数
    {
        hello();
    }
    ~CSon()  // 析构函数
    {
        bye();
    }
    virtual void hello() // 虚函数
    {
        cout << "hello from son" << endl;
    }
};
int main()
{
    CSon son;
    CFather* pfather;
    pfather = &son;
    pfather->hello(); //多态
    return 0;
}

结果为:

hello from son // 构造son对象时执行的构造函数
hello from son // 多态
bye from father // son对象析构时,由于CSon类没有bye成员函数,所以调用了基类的bye成员函数

多态的实现原理

「多态」的关键在于通过基类指针或引用调用一个虚函数时,编译时不能确定到底调用的是基类还是派生类的函数,运行时才能确定。

class A
{
public:
    int i;
    virtual void Print() { } // 虚函数
};
class B
{
public:
    int n;
    void Print() { }
};
int main()
{
    cout << sizeof(A) << ","<< sizeof(B);
    return 0;
}

在32位机子中:8 4

从上面的结果,可以发现有虚函数的类,多出了4 个字节,在 32 位机子上指针类型大小正好是 4 个字节,这多出 4 个字节的指针有什么作用呢?

虚函数表

每一个有「虚函数」的类(或有虚函数的类的派生类)都有一个「虚函数表」,该类的任何对象中都放着虚函数表的指针。「虚函数表」中列出了该类的「虚函数」地址。

多出来的 8 个字节就是用来放「虚函数表」的地址。

// 基类
class Base
{
public:
    int i;
    virtual void Print() { } // 虚函数
};
// 派生类
class Derived : public Base
{
public:
    int n;
    virtual void Print() { } // 虚函数
};

上面 Derived 类继承了 Base类,两个类都有「虚函数」,那么它「虚函数表」的形式可以理解成下图:

多态的函数调用语句被编译成一系列根据基类指针所指向的(或基类引用所引用的)对象中存放的虚函数表的地址,在虚函数表中查找虚函数地址,并调用虚函数的指令

虚析构函数

析构函数是在删除对象或退出程序的时候,自动调用的函数,其目的是做一些资源释放。

那么在多态的情景下,通过基类的指针删除派生类对象时,通常情况下只调用基类的析构函数,这就会存在派生类对象的析构函数没有调用到,存在资源泄露的情况。

比如:

// 基类
class A
{
public:
    A()  // 构造函数
    {
        cout << "construct A" << endl;
    }
    ~A() // 析构函数
    {
        cout << "Destructor A" << endl;
    }
};
// 派生类
class B : public A
{
public:
    B()  // 构造函数
    {
        cout << "construct B" << endl;
    }
    ~B()// 析构函数
    {
        cout << "Destructor B" << endl;
    }
};
int main()
{
    A *pa = new B();
    delete pa;
    return 0;
}

输出结果:

construct A
construct B
Destructor A

从上面的输出结果可以看到,在删除 pa指针对象时,B 类的析构函数没有被调用

解决办法:把基类的析构函数声明为virtual

  • 派生类的析构函数可以 virtual 不进行声明
  • 通过基类的指针删除派生类对象时,首先调用派生类的析构函数,然后调用基类的析构函数,还是遵循「先构造,后虚构」的规则
// 基类
class A
{
public:
    A()
    {
        cout << "construct A" << endl;
    }
    virtual ~A() // 虚析构函数
    {
        cout << "Destructor A" << endl;
    }
};

输出结果:

construct A
construct B
Destructor B
Destructor A

纯虚函数和抽象类

纯虚函数: 没有函数体的虚函数

class A
{
public:
    virtual void Print( ) = 0 ; //纯虚函数
private:
    int a;
};

包含纯虚函数的类叫抽象类

  • 抽象类只能作为基类来派生新类使用,不能创建抽象类的对象
  • 抽象类的指针和引用可以指向由抽象类派生出来的类的对象
A a;         // 错,A 是抽象类,不能创建对象
A * pa ;     // ok,可以定义抽象类的指针和引用
pa = new A ; // 错误, A 是抽象类,不能创建对象

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • c++中为什么可以通过指针或引用实现多态详解

    引言: 在c++中司空见惯的事情就是:可以通过指针和引用可以实现多态,而对象不可以. 那为什么?让我们来解开这神秘的暗纱! 1. 类对象的存储方式: 在一个类的实例中,只会存放非静态的成员变量. 如果该类中存在虚函数的话,再多加一个指向虚函数列表指针-vptr. 例如声明如下两个类,并分别实例化两个对象,它们的内存分配大致如下:(vptr具体在什么位置,与编译器有关,大多数都在开始处) class base { public: virtual ~base() {}; virtual string

  • C++中的多态详谈

    1. 多态概念 1.1 概念 多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态. 举个栗子:比如买票,当普通人买票时,是全价买票:学生买票时,是半价买票:军人买票时是优先买票.同一个事情针对不同的人或情况有不同的结果或形态. 2. 多态的定义及实现 2.1 多态的构成条件 多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为.比如Student继承了Person. Person对象买票全价,Student对象买票半价. 注意:那么在继

  • C++中多态的定义及实现详解

    1. 多态概念 1.1 概念 多态的概念:通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态. 举个栗子:比如买票,当普通人买票时,是全价买票:学生买票时,是半价买票:军人买票时是优先买票.同一个事情针对不同的人或情况有不同的结果或形态. 2. 多态的定义及实现 2.1 多态的构成条件 多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为.比如Student继承了Person. Person对象买票全价,Student对象买票半价. 注意:那么在继

  • 虚函数表-C++多态的实现原理解析

    参考:http://c.biancheng.net/view/267.html 1.说明 我们都知道多态指的是父类的指针在运行中指向子类,那么它的实现原理是什么呢?答案是虚函数表 在 关于virtual 一文中,我们详细了解了C++多态的使用方式,我们知道没有 virtual 关键子就没法使用多态 2.虚函数表 我们看一下下面的代码 class A { public: int i; virtual void func() { cout << "A func" <<

  • C++利用多态实现职工管理系统(项目开发)

    分析 首先看一下这个项目的文件: 主要分为两部分: 主体部分: main.cpp和workManager.h,workManager.cpp职工部分(这里采用多态的方式编写): 主要是worker.h和worker.cpp 三种职位:boss,employee,manager 经过分析是否大概知道了其中各部分的意思呢? 看起来这里面有很多,但是正是这种多个文件编写才时代码更加简洁. 所以在正式写项目之前一定要先考虑好整体架构,在进行编写. 项目整体架构: 这个项目的难度并不大,主要是要学会这个项

  • 一篇文章带你了解C++多态的实现原理

    目录 虚函数和多态 多态的作用 多态的一个例子 构造函数和析构函数中存在多态吗? 多态的实现原理 虚函数表 虚析构函数 纯虚函数和抽象类 总结 虚函数和多态 虚函数: 在类的定义中,前面有 virtual 关键字的成员函数称为虚函数 virtual 关键字只用在类定义里的函数声明中,写函数体时不用 比如: class Base { virtual int Fun() ; // 虚函数 }; int Base::Fun() // virtual 字段不用在函数体时定义 { } 多态的表现形式 派生

  • 一篇文章带你搞懂Python类的相关知识

    一.什么是类 类(class),作为代码的父亲,可以说它包裹了很多有趣的函数和方法以及变量,下面我们试着简单创建一个吧. 这样就算创建了我们的第一个类了.大家可以看到这里面有一个self,其实它指的就是类aa的实例.每个类中的函数只要你不是类函数或者静态函数你都得加上这个self,当然你也可以用其他的代替这个self,只不过这是python中的写法,就好比Java 中的this. 二.类的方法 1.静态方法,类方法,普通方法 类一般常用有三种方法,即为static method(静态方法),cl

  • 一篇文章带你了解Java Spring基础与IOC

    目录 About Spring About IOC Hello Spring Hello.java Beans.xml Test.java IOC创建对象的几种方式 Spring import settings Dependency Injection 1.构造器注入 2.set注入 3.拓展注入 P-namespcae&C-namespace Bean scopes singleton prototype Bean的自动装配 byName autowire byType autowire 小结

  • 一篇文章带你使用Typescript封装一个Vue组件(简单易懂)

    一.搭建项目以及初始化配置 vue create ts_vue_btn 这里使用了vue CLI3自定义选择的服务,我选择了ts.stylus等工具.然后创建完项目之后,进入项目.使用快捷命令code .进入Vs code编辑器(如果没有code .,需要将编辑器的bin文件目录地址放到环境变量的path中).然后,我进入编辑器之后,进入设置工作区,随便设置一个参数,这里比如推荐设置字号,点下.这里是为了生成.vscode文件夹,里面有个json文件. 我们在开发项目的时候,项目文件夹内的文件很

  • 一篇文章带你搞定SpringBoot中的热部署devtools方法

    一.前期配置 创建项目时,需要加入 DevTools 依赖 二.测试使用 (1)建立 HelloController @RestController public class HelloController { @GetMapping("/hello") public String hello(){ return "hello devtools"; } } 对其进行修改:然后不用重新运行,重新构建即可:只加载变化的类 三.热部署的原理 Spring Boot 中热部

  • 一篇文章带你搞定SpringBoot不重启项目实现修改静态资源

    一.通过配置文件控制静态资源的热部署 在配置文件 application.properties 中添加: #表示从这个默认不触发重启的目录中除去static目录 spring.devtools.restart.exclude=classpath:/static/** 或者使用: #表示将static目录加入到修改资源会重启的目录中来 spring.devtools.restart.additional-paths=src/main/resource/static 此时对static 目录下的静态

  • 一篇文章带你解决 IDEA 每次新建项目 maven home directory 总是改变的问题

    Maven是基bai于项目对象模型,可以通du过一小段描述信息来管理zhi项目的构建,报告和文档的软件项dao目管理工具. 重装个系统,各种问题,idea 也出现各种问题 装了个新版的 idea 2020 2.x 版本的,不知道咋回事,其他都好使,就是创建 SpringBoot 项目时: 加载 pom.xml 总是出错,原因就是,新建立的项目 maven home directory 总是乱,没有安装 设置的默认方式 我试了,改当前项目的,不好使 该默认设置,不好使,网上的其他方法也试了,很奇怪

  • 一篇文章带你使用SpringBoot基于WebSocket的在线群聊实现

    一.添加依赖 加入前端需要用到的依赖: <dependency> <groupId>org.webjars</groupId> <artifactId>sockjs-client</artifactId> <version>1.1.2</version> </dependency> <dependency> <groupId>org.webjars</groupId> <

  • 一篇文章带你搞定 springsecurity基于数据库的认证(springsecurity整合mybatis)

    一.前期配置 1. 加入依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.10</version> </dependency> <dependency> <groupId>mysql</groupId> &

  • 一篇文章带你搞定Ubuntu中打开Pycharm总是卡顿崩溃

    由于 Ubuntu 中的汉字输入实在是太不友好了,所以装了个 搜狗输入法,好不容易把 搜狗输入法装好,本以为可以开开心心的搞代码了,然而... pycharm 一打开,就崩溃,关不掉,进程杀死还是不行,只能关机重启. 本以为 pycharm 出现了问题,又重装了两遍,还是不行. 最终发现竟然是搜狗输入法以及 fcitx 输入法的锅 唉,只能老老实实的把 fctix 和搜狗输入法卸载了: (1)Ubuntu 软件里卸载 fctix,然后将键盘输入法系统改成 IBus (2)卸载搜狗输入法 先查找软

随机推荐