虚函数与多态

最新推荐文章于 2024-07-26 22:51:51 发布
最新推荐文章于 2024-07-26 22:51:51 发布
阅读量3.2k 收藏 9
点赞数 5
文章标签： c++ 虚函数 纯虚函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luoweifu/article/details/46948453
版权

假设我们有三个类Person、Teacher、Student它们之间的关系如下：


这里写图片描述
类的关系图

普通成员函数

【Demo1】
根据这个类图，我们有下面的代码实现

#ifndef __OBJEDT_H__
#define  __OBJEDT_H__

#include <string>
#include <iostream>

class Person
{
public:
    Person(const string& name, int age) : m_name(name), m_age(age)
    {
    }

    void ShowInfo()
    {
        cout << "姓名：" << m_name << endl;
        cout << "年龄：" << m_age << endl;
    }

protected:
    string  m_name;     //姓名
    int     m_age;      //年龄
};


class Teacher : public Person
{
public:
    Teacher(const string& name, int age, const string& title)
        : Person(name, age), m_title(title)
    {
    }

    void ShowInfo()
    {
        cout << "姓名：" << m_name << endl;
        cout << "年龄：" << m_age << endl;
        cout << "职称：" << m_title << endl;
    }

private:
    string  m_title;        //职称
};

class Student : public Person
{
public:
    Student(const string& name, int age, int studyId)
        : Person(name, age), m_studyId(studyId)
    {
    }

    void ShowInfo()
    {
        cout << "姓名：" << m_name << endl;
        cout << "年龄：" << m_age << endl;
        cout << "学号：" << m_studyId << endl;
    }

private:
    int m_studyId;          //学号
};

#endif  //__OBJEDT_H__

测试代码：

void test()
{
    Person* pPerson = new Person("张三", 22);
    Teacher* pTeacher = new Teacher("李四", 35, "副教授");
    Student* pStudent = new Student("王五", 18, 20151653);
    pPerson->ShowInfo();
    cout << endl;
    pTeacher->ShowInfo();
    cout << endl;
    pStudent->ShowInfo();
    cout << endl;
    delete pPerson;
    delete pTeacher;
    delete pStudent;
}

结果：

姓名：张三
年龄：22

姓名：李四
年龄：35
职称：副教授

姓名：王五
年龄：18
学号：20151653

说明：
这里的ShowInfo就是一个普通的函数。pPerson、pTeacher和pStudent三个对象调用ShowInfo分别展示自己的信息。
我们知道：父类的指针是可以指向子类的对象的。我们把上面的测试代码稍微改一下：
【Demo2】

void test()
{
    Person* pPerson = new Person("张三", 22);
    Person* pTeacher = new Teacher("李四", 35, "副教授");
    Person* pStudent = new Student("王五", 18, 20151653);
    pPerson->ShowInfo();
    cout << endl;
    pTeacher->ShowInfo();
    cout << endl;
    pStudent->ShowInfo();
    cout << endl;
    delete pPerson;
    delete pTeacher;
    delete pStudent;
}

结果：

姓名：张三
年龄：22

姓名：李四
年龄：35

姓名：王五
年龄：18

这时，pTeacher和pStudent只输出了姓名和年龄，并没有输出子类所具有的特性(职称和学号)。这应该不是你期望的结果，你可能期望pTeacher和pStudent输出老师和学生的完整信息，这时就需要用虚函数。

虚函数

我们把Person中的ShowInfo成员改成虚函数(在前面加上virtual)，代码如下：
【Demo3】

class Person
{
public:
    Person(const string& name, int age) : m_name(name), m_age(age)
    {
    }

    virtual void ShowInfo()
    {
        cout << "姓名：" << m_name << endl;
        cout << "年龄：" << m_age << endl;
    }

protected:
    string  m_name;     //姓名
    int     m_age;      //年龄
};

在执行上面【Demo2】中的测试代码，得到我们想到的结果：

姓名：张三
年龄：22

姓名：李四
年龄：35
职称：副教授

姓名：王五
年龄：18
学号：20151653

虚函数用法要点：

  1. 虚函数的声明方式：

    virtual RETURN_TYPE functionName(ARGS 参数列表);

  2. 虚函数作用：现实C++中的多态，进行动态绑定(父类指针可指向子类的对象)，直到运行时才知道要调用哪个版本(哪个类定义)的函数；

  3. 我们必要对虚函数进行定义；
  4. 一旦父类的成员函数声明virtual，其子类的函数不管有没有声明为virtual，都是虚函数；
  5. 如果虚函数使用默认实参，父类和子类定义的默认实参最好一致。

【Demo4】:针对第4点说明：

class Person
{
public:
    Person(const string& name, int age) : m_name(name), m_age(age)
    {
    }

    virtual void ShowInfo()
    {
        cout << "姓名：" << m_name << endl;
        cout << "年龄：" << m_age << endl;
    }

    string GetName();       //正确，普通函数如果不被使用，可以只有声明没有定义
    virtual int GetAge();   //错误，虚函数必须要有定义，即使是一个空实现,因为编译器无法确定会使用哪个函数


protected:
    string  m_name;     //姓名
    int     m_age;      //年龄
};

【Demo5】:针对第5点进行说明：
设计我们的类如下定义。

class Person
{
public:
    virtual void SetAge(int age = 0)
    {
        m_age = age;
    }
    //... 省略
};


class Teacher : public Person
{
public:
    virtual void SetAge(int age = 1)
    {
        m_age = age;
    }

    //... 省略
};

class Student : public Person
{
public:
    virtual void SetAge(int age = 2)
    {
        m_age = age;
    }

    //... 省略
};

测试1：

void test()
{
    Person* pPerson = new Person("张三", 22);
    Teacher* pTeacher = new Teacher("李四", 35, "副教授");
    Student* pStudent = new Student("王五", 18, 20151653);
    pPerson->SetAge();
    pTeacher->SetAge();
    pStudent->SetAge();

    pPerson->ShowInfo();
    cout << endl;
    pTeacher->ShowInfo();
    cout << endl;
    pStudent->ShowInfo();
    cout << endl;
    delete pPerson;
    delete pTeacher;
    delete pStudent;
}

结果：

姓名：张三
年龄：0

姓名：李四
年龄：1
职称：副教授

姓名：王五
年龄：2
学号：20151653

测试2：

void test()
{
    Person* pPerson = new Person("张三", 22);
    Person* pTeacher = new Teacher("李四", 35, "副教授");
    Person* pStudent = new Student("王五", 18, 20151653);
    pPerson->SetAge();
    pTeacher->SetAge();
    pStudent->SetAge();

    pPerson->ShowInfo();
    cout << endl;
    pTeacher->ShowInfo();
    cout << endl;
    pStudent->ShowInfo();
    cout << endl;
    delete pPerson;
    delete pTeacher;
    delete pStudent;
}

结果：

姓名：张三
年龄：0

姓名：李四
年龄：0
职称：副教授

姓名：王五
年龄：0
学号：20151653

纯虚函数

在上面的例子中，我们假设所有的人都要工作，但不同的人工作的方式不同。于是我们就要强制要求继承自Person的子类都要有工作的方法，这就需要纯虚函数。定义如下：
【Demo6】

class Person
{
public:
    //... 省略
    virtual void DoWork() = 0;
        //... 省略
};

但此时我们编译

Person* pPerson = new Person("张三", 22);

这句话时会报错:error C2259: ‘Person’ : cannot instantiate abstract class
这是因为我们并没有为Person实现DoWork方法，而包含纯虚函数的类是一个抽象的类，抽象类不能被实例化。

于是我们在子类中对它实现如下：
【Demo7】

class Teacher : public Person
{
public:
    //... 省略
    virtual void DoWork()
    {
        cout << "教书..." << endl;
    }
    //... 省略
};

class Student : public Person
{
public:
    //... 省略
    virtual void DoWork()
    {
        cout << "学习..." << endl;
    }
    //... 省略
};

没用DoWork方法:

void test()
{
    Person* pTeacher = new Teacher("李四", 35, "副教授");
    Person* pStudent = new Student("王五", 18, 20151653);

    pTeacher->DoWork();
    cout << endl;
    pStudent->DoWork();
    cout << endl;

    delete pTeacher;
    delete pStudent;
}

结果：

教书…

学习…

纯虚函数用法要点：

  1. 纯虚函数的声明方式：

    virtual RETURN_TYPE functionName(ARGS 参数列表) = 0;

  2. 含有纯虚函数的类是一个抽象的类，抽象类不能被实例化。

  3. 包含纯虚函数的抽象类常用来当作对外的接口，说明这个类有什么功能，而没有具体的实现，基体的实现交由子类完成。
陌尘(MoChen)
关注
专栏目录
深入解析C++中的虚函数与多态
01-21
1.C++中的虚函数C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是...
虚函数和多态
Ryzen3的博客
04-14 2375
虚函数和多态的基础知识
虚函数与多态性
qq_45838321的博客
06-18 494
一.静态联编 1.联编是指一个程序自身彼此关联的过程,在这个联编过程中,需要确定程序中的操作调用(函数调用)与执行该操作(函数)的代码段之间的映射关系; 就是把函数调用与函 数的程序代码连接（联系）在一起的过程。 2.联编分为两大类 1）静态联编 调用速度快，效率高，但缺乏灵活性。 C++为了兼容C语言仍然是编译型的，采用静态联编。 2）动态联编 运行效率低，但增强了程序灵活性。 为了实现多态性，利用虚函数机制，可部分地采用动态联编。 二.类指针的关系 基类指针和派生类指针与基类对象和派生类对象4种可能匹配
C++:虚函数与多态
最新发布
2301_79959126的博客
07-26 744
本文介绍了C++中的虚函数与多态的概念，并介绍了虚函数与多态的实现原理。
【C++入门】(纯)虚函数和多态、抽象类、接口
weixin_42031299的博客
10-28 1690
(1)当基类含有1个或多个虚函数时，其析构函数需要声明为virtual虚函数；(2)将析构函数定义为虚函数，可以保证派生类析构时能调用正确的析构函数；(1)虚函数的作用是实现面向对象的多态效果，让成员函数在运行时动态解析和绑定具体的执行函数；(2)将成员函数定义为virtual虚函数是有额外开销的，因为要在运行时动态绑定；如果是普通函数，在编译时就可以确定并绑定完成；
多态与虚函数
Hustle Everyday
03-07 965
一、什么是多态 多态就是向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为。也就是说，每个对象可以用自己的方式去响应共同的消息。使用相同的代码实现不同的动作，体现了面向对象编程的优越性。 在C++中，多态就是利用基类指针指向子类实例，通过基类指针调用子类（虚）函数从而实现“一个接口，多种形态”的效果。 简单的说就是，实现了一个函数会根据传入参数的不同有不同的功能，比如： vo...
实验三虚函数与多态纯虚函数完整版.pdf
10-08
在本文档中，主要讲述了面向对象编程中的两个重要概念：虚函数和多态。同时，纯虚函数作为多态中一个重要的组成部分，也在本实验文档中得到了介绍。 首先，我们需要了解什么是虚函数。在C++中，虚函数是一种特殊的...
实验三虚函数与多态纯虚函数.doc
09-29
实验三虚函数与多态纯虚函数.doc
虚函数与多态（一）
INGNIGHT的专栏
05-26 999
1.多态 （1）多态性是面向对象程序设计的重要特征之一。 （2）多态性是指发出相同的消息被不同类型的对象接收时，有可能导致完全不同的行为。 （3）多态的实现：函数重载，运算符重载，模板，虚函数 2.静态绑定与动态绑定 （1）静态绑定：绑定过程出现在编译阶段，在编译期就已确定要调用的函数。 （2）动态绑定：绑定过程工作在程序运行时执行，在程序运行时才确定将要...
虚函数和多态性
Xuersry的博客
06-10 844
多态性是面向对象程序设计的重要特征之一。所谓的多态性指的是一个名字可以具有多个语义。前面介绍的函数重载、类模板和函数模板都属于多态性，用户只需要发送一般形式的消息，而将所有的实现留给所接受消息的对象，对象根据所接收到的消息，而做出相应的动作（即操作）。本章介绍的虚函数，就是C++实现多态性的另一个重要机制。 · 1·函数绑定 函数绑定就是函数的入口地址同函数调用相联系的的过程。函数调用指令由操作码和地址码两部分构成，地址码就是被调用函数的入口地址，绑定就是要计算机被调用函数的入口地址，并将该地址存放在函数调
多态 + 虚函数
Hi海底的博客
05-18 373
学习博客： 虚函数 CSDN- 虚函数 多态 多态是面向对象的三大特征之一，其它两大特征分别是 封装 和 继承。 面向对象的三大特征：封装、多态、继承 所谓 多态，简单来说，就是当发出一条命令时，不同的对象接收到同样的命令后所做出的动作是不同的。 书本上的定义：指相同对象收到不同消息或不同对象收到系统消息时产生不同的动作。 分为动态多态和静态多态： 静态多态 静态多态，也叫 早绑定 看如下实例：定义一个矩形类：Rect，其中有两个同名成员函数：calcArea()，显然 二者互为重载.
C++——多态|虚函数|重写|虚表
博主qq1077644249
02-13 3205
1. 多态的概念 1.1 概念 2. 多态的定义及实现 2.1多态的构成条件 2.2 虚函数 2.3虚函数的重写 虚函数重写的三个例外： 2.4 普通调用和多态调用： 2.5 C++11 override 和 final 2.6 重载、虚函数的覆盖(重写)、隐藏(重定义)的对比 3. 抽象类(有关纯虚函数) 3.1 概念 3.2 接口继承和实现继承 4.多态的原理 4.1虚函数表 派生类的虚表生成流程： 虚函数存在哪的？**虚表**存在哪的？ 4.2多态的原理 4.3 动态绑定与静态绑定 5.单继承
c++复习之多态与虚函数
guangod的博客
07-05 405
多态与虚函数多态概念使用普通成员函数实现多态虚函数使用虚析构函数纯虚函数和抽象类抽象类虚基类 多态 面向对象3种机制之一（封装、继承、多态），提高程序的可读性，可扩展性和可重用性。 概念 不同对象可以调用相同名称的函数，但可导致完全不同的行为的现象。 多态实现的是接口的复用。不论传递过来是哪个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。 使用 编译时多态（静态多态）：即函数重载，在编译时就能绑定调用语句与调用函数入口地址。 运行时多态（动态多态）函数调用与代码入口地址的绑定需要在运行时刻
C++专题：多态性与虚函数（详细！）
m0_70983574的博客
07-21 2397
对C++的多态性和虚函数进行了详细介绍
C++虚函数与多态：理解与应用
继承与虚函数结合使用时，通过虚函数表（VTable）来存储每个对象的真实函数地址，不论它是哪个子类的对象。当调用一个虚函数时，实际上是通过对象的类型在VTable中找到正确的函数地址进行调用。这种方式使得基类和其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

陌尘(MoChen)

爱打赏的人技术成长更开哦~

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

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

打赏作者

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

抵扣说明：

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

余额充值