C++中的多态：虚函数

最新推荐文章于 2024-07-26 22:51:51 发布
最新推荐文章于 2024-07-26 22:51:51 发布
阅读量512 收藏 1
点赞数
分类专栏： C++基础语法学习 文章标签： 多态 c++ 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45488242/article/details/108581180
版权

C++中的多态：虚函数

上一章讲解了C++中类的继承，这一节将讲解面向对象编程的核心：多态

本章内容如下：

  • 什么是多态
  • 虚函数的用途和用法
  • 什么是抽象类以及如何声明他们
  • 什么是虚继承以及在什么情况下使用虚继承

多态基础

多态的英语是ploymorphism, ploy源自于希腊语，是多的意思，而morhph是形态的意思。

多态是面向对象语言的基础，能够让我们以类似的方式处理不同而又类似的对象。

多态即多种形态，指的是在面向对象语言中，接口的多种不同的实现方式。其目的是为了实现借口重用，对于函数而言就是对函数名等标识符进行重复利用

之所以称为多态是因为同一个函数名的函数具有多种形态，能够根据不同的输入来进行不同的调用。

所以实际上我们前面所讲的，对函数进行重载和使用重载构造函数就是多态的一个具体的例子，本节的主要讲解C++类中的多态

类中的多态也是相同的含义，我们将在下面进行讲解

类中的多态

类中的多态引入

我们首先看下面的一个例子

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    void Swim(){
        cout << "鱼在游泳" << endl;
    }
};

class Tuna : public Fish
{
public:
    void Swim(){
        cout << "金枪鱼在游泳" << endl;
    }
};

void FishSwim(Fish & aFish){
    aFish.Swim();
}

int main(){
    Tuna aTuna;
    FishSwim(aTuna);
    return 0;
}

编译成功之后运行得到如下的结果

jackwang@jackwang-ThinkPad-X390-Yoga:~/桌面/TryC++$ ./TryPolymorphism 
>>>
鱼在游泳

我们期望得到的结果是调用Tuna类中的Swim方法，但是因为我们FishSwim函数中声明接受一个Fish对象的引用，因此我们在FishSwim中调用Swim方法实际上会运行Fish类中的Swim方法

我们想要解决这个问题，一种思路就是对FishSwim这个函数进行重载，编写一个接受Tuna类的引用的FishSwim函数。但是本章的内容针对的是类中的多态，因此我们将使用另外一种方法来解决这个问题，就是通过将Fish类中的Swim方法声明为虚函数从而解决这个问题

使用虚函数

我们使用关键字virtual来定义一个虚函数

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void Swim(){
        cout << "鱼在游泳" << endl;
    }
};

class Tuna : public Fish
{
public:
    void Swim(){
        cout << "金枪鱼在游泳" << endl;
    }
};

void FishSwim(Fish & aFish){
    aFish.Swim();
}

int main(){
    Tuna aTuna;
    FishSwim(aTuna);
    return 0;
}

编译成功后运行得到如下结果

jackwang@jackwang-ThinkPad-X390-Yoga:~/桌面/TryC++$ ./TryPolymorphism
>>>
金枪鱼在游泳

这里我们使用了关键字virtual来将Fish类中的Swim方法定义为了一个虚函数，这样就解决了这个问题

类中的多态的含义

这里我们不禁要问了，我们在FishSwim函数中命名传入的是一个Fish类的引用，我们调用这个引用的各种方法按理来说应该表现出Fish类的方法，但是这里在上面的例子中却表现出了另外一个类Tuna的特性，即基类表现出了派生类的性态

这就是类中的多态的含义，让基类表现派生类的性态，从而使得基类具有了多种形态

我们实现类中的多态，具体的方法就是使用virtual关键字来定义虚函数。

虚函数

上面讲解了类中的多态的含义，我们发现实现类的多态的核心就是使用关键字virtual来将类中的方法声明为虚函数，进而实现类中的多态

而virtual关键字的本质是降低对应函数在调用时的优先级，优先让派生类的函数发挥作用

下面将详细讲解C++中的虚函数

使用关键字virtual定义虚函数

我们可以使用关键字virtual来定义一个虚函数

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void Swim(){
        cout << "鱼在游泳" << endl;
    }
};

class Tuna : public Fish
{
public:
    void Swim(){
        cout << "金枪鱼在游泳" << endl;
    }
};

void FishSwim(Fish & aFish){
    aFish.Swim();
}

int main(){
    Tuna aTuna;
    FishSwim(aTuna);
    return 0;
}

定义虚构造函数

我们在前面讲过，我们实例化一个派生类对象的时候，首先会调用基类的构造函数来为派生类的实例化做好准备，接下来才会调用派生类的构造函数

那么结合上面讲的多态，就会有一个问题了，我们如果让指向基类的指针表现出派生类的特性的话，那么将会出现什么样的结果？

我们以下面的例子为例进行讲解

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    Fish(){
        cout << "调用Fish类的构造函数" << endl;
    }

    ~Fish(){
        cout << "调用Fish类的析构函数" << endl;
    }
};

class Tuna : public Fish
{
public:
    Tuna(){
        cout << "调用Tuna类的构造函数" << endl;
    }
    ~Tuna(){
        cout << "调用Tuna类的析构函数" << endl;
    }
};

void DeletePoniter(Fish * aFishPointer){
    cout << "进入DeletePoniter函数内部" << endl;
    cout << "开始释放指向Tuna的指针" << endl;
    delete aFishPointer;
}

int main(){
    cout << "创建指向Tuna的指针" << endl;
    Tuna * aTunaPointer = new Tuna;
    DeletePoniter(aTunaPointer);
    return 0;
}

这里我们在DeletePointer函数中声明的是指向Fish类的指针，虽然我们传入的是指向Tuna类的指针，从而使得函数中指向基类的指针具有了派生类的特性。我们编译成功之后运行得到如下结果

jackwang@jackwang-ThinkPad-X390-Yoga:~/桌面/TryC++$ ./TryPolymorphism 
>>>
创建指向Tuna的指针
调用Fish类的构造函数
调用Tuna类的构造函数
进入DeletePoniter函数内部
开始释放指向Tuna的指针
调用Fish类的析构函数

我们发现具有多态的指针在释放的时候并不会调用派生类的析构函数，这将会导致资源未释放，内存泄露等问题

为此，我们需要降低基类中的析构函数的优先级，将其声明为虚函数即可

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    Fish(){
        cout << "调用Fish类的构造函数" << endl;
    }

    virtual ~Fish(){
        cout << "调用Fish类的析构函数" << endl;
    }
};

class Tuna : public Fish
{
public:
    Tuna(){
        cout << "调用Tuna类的构造函数" << endl;
    }
    ~Tuna(){
        cout << "调用Tuna类的析构函数" << endl;
    }
};

void DeletePoniter(Fish * aFishPointer){
    cout << "进入DeletePoniter函数内部" << endl;
    cout << "开始释放指向Tuna的指针" << endl;
    delete aFishPointer;
}

int main(){
    cout << "创建指向Tuna的指针" << endl;
    Tuna * aTunaPointer = new Tuna;
    DeletePoniter(aTunaPointer);
    return 0;
}

编译成功之后运行得到的结果如下

jackwang@jackwang-ThinkPad-X390-Yoga:~/桌面/TryC++$ ./TryPolymorphism
>>>
创建指向Tuna的指针
调用Fish类的构造函数
调用Tuna类的构造函数
进入DeletePoniter函数内部
开始释放指向Tuna的指针
调用Tuna类的析构函数
调用Fish类的析构函数

这样就能避免上面的问题

虚函数的工作原理：虚函数表

前面的代码中我们在FishSwim函数中声明的是接受一个Fish的引用，接下来调用Fish中的Swim方法，但是为函数传入一个Tuna类的对象完全是由用户所决定的，编译器事先是无法预知我们到底会向函数中传入什么类型的参数

如果我们向其中放入一个Fish类，函数调用了Fish类的Swim方法，这是完全正常的。但是我们向其中放入一个Tuna类，编译器也能够知道调用Tuna类的Swim方法（在使用虚函数的情况下）。

其实这是虚函数的工作原理所导致的，下面就将讲解虚函数的工作原理：虚函数表

我们将基于下面的代码进行讲解

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void FunctionFish_1(){}
    virtual void FunctionFish_2(){}
    virtual void FunctionFish_3(){}
};

class Tuna : public Fish
{
public:
    virtual void FunctionTuna_1(){}
    virtual void FunctionTuna_2(){}
};

int main(){
    return 0;
}

上面的代码中,我们在Fish类中声明了三个虚函数，分别是：Function_1,Function_2,Function_3

在Tuna类中，我们声明了两个将会覆盖Fish类的虚函数：Function_1和Function_2

编译器在编译的时候，当发现派生类中覆盖了基类中的虚函数时候，就会为实现了虚函数的基类和覆盖了虚函数的派生类分别创建一个虚函数表（Virtual Function Table，VFT）

虚函数表本质上是一个静态的指针数组，其中的指针分别指向各自类的虚函数,如果基类中具有派生类没有的虚函数,那么派生类的VFT中将会包含指向基类的虚函数的指针

所以上面的例子中,两个类的虚函数表如下

[*FunctionFish_1,*FunctionFish_2,*FunctionFish_3]
[*FunctionTuna_1,*FunctionTuna_2,*FunctionFish_2]

此外,当我们实例化一个Fish类或者Tuna类的时候，编译器都会创建一个隐藏的指针（称为*VFT）指向对应类型的VFT

因此我们使用下面语句的时候,编译器会查找Tuna类中的虚函数表,来确保调用FunctionFish_2

Tuna aTuna;
aTuna.FunctionFish_2();

同样,当我们以下面的方式来调用,也会在Tuna类的虚函数表中查找

void FishSwim(Fish & aFish){
    aFish.FunctionTuna_1();
}
int main(){
    Tuna aTuna;
    FishSwim(aTuna);
    return 0;
}

虽然我们将aTuna对象传入了FishSwim函数导致aTuna被视为一个Fish实例来进行处理,但是其VFT指针依旧指向Tuna类的虚函数表,因此会执行Tuna的FunctiionTuna_1.

我们通过下面的代码来确定的确创建了虚函数表

#include <iostream>

//导入命名空间
using namespace std;

class FishWithoutVirtual
{
public:
    void FunctionFish_1(){}
    void FunctionFish_2(){}
    void FunctionFish_3(){}
};

class FishWithVirtual
{
public:
    virtual void FunctionFish_1(){}
    virtual void FunctionFish_2(){}
    virtual void FunctionFish_3(){}
};

int main(){
    cout << "类FishWithoutVirtual的大小是："  << sizeof(FishWithoutVirtual) << endl;
    cout << "类FishWithVirtual的大小是："  << sizeof(FishWithVirtual) << endl;
    return 0;
}

编译成功之后运行得到的结果如下

jackwang@jwang:~/桌面/TryC++$ ./TryPloymorphism 
>>>
类FishWithoutVirtual的大小是：1
类FishWithVirtual的大小是：8

抽象基类和纯虚函数

不能实例化的基类成为抽象基类,抽象基类只有一个用途:从抽象基类中派生其他类

而我们创建抽象基类的方法就是声明其中的函数为纯虚函数

而且作为抽象基类的派生类中必须覆盖纯虚函数,即定义有效的与纯虚函数同名的函数

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void Swim() = 0;
};


int main(){
    return 0;
}

这样我们声明的Fish类就是一个抽象基类,而其中的Swim()就是纯虚函数

我们创建一个继承Fish类的Tuna类

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void Swim() = 0;
};

class Tuna : public Fish
{
public:
    void Swim(){
        cout << "金枪鱼有用" << endl;
    }
};
int main(){
    return 0;
}

所以抽象基类的功能就是约束派生类,即在抽象基类中统一规定所有继承自该抽象基类的派派生类必须具有的方法

虚继承解决多继承问题

在讲解多继承的时候,我们使用了两栖动物的例子,两栖动物派生自陆生动物和水生动物,而陆生动物和水生动物都是派生自动物的,所以两栖动物存在菱形继承的问题

示例代码如下

#include <iostream>

//导入命名空间
using namespace std;

class Animal
{
public:
    int age;
    Animal(){
        cout << "执行了Animal的构造函数" << endl;
    }
};

class AquaticAnimal : public Animal
{
public:
    AquaticAnimal(){
        cout << "执行了AquaticAnimal的构造函数" << endl;
    }
};

class TerrestrialAnimal: public Animal
{
public:
    TerrestrialAnimal(){
        cout << "执行了TerrestrialAnimal中的构造函数" << endl;
    }
};

class Amphibia : public AquaticAnimal, public TerrestrialAnimal
{
public:
    Amphibia(){
        cout << "执行了Amphibia中的构造函数" << endl;
    }
};

int main(){
    Amphibia aAmphibia;
    return 0;
}

这样我们在实例化Amphibia对象的时候,会首先实例化AquaticAnimal和TerrestrialAnimal来做准备,进而首先会执行两次Animal来做准备

因此,编译成功之后运行得到的结果如下

jackwang@jwang:~/桌面/TryC++$ ./TryPloymorphism 
>>>
执行了Animal的构造函数
执行了AquaticAnimal的构造函数
执行了Animal的构造函数
执行了TerrestrialAnimal中的构造函数
执行了Amphibia中的构造函数

而这种方式会导致两个问题

首先是我们实例化一个Amphibia对象会自动创建两个Animal的实例,这就造成了内存的浪费.

其次,由于Animal中还要age属性,所以Amphibia类中实际上具有两个age属性,分别是:AquaticAnimal::Animal::age和TerrestrialAnimal::Animal::age

所以我们单纯的使用aAmphibia.age的时候会报错,因为编译器不知道具体要调用那个属性

更加可笑的是,我们可以分别为这两个属性设置值,即便都是aAmphibia对象的属性

解决这个问题,我们可以使用虚继承来解决

使用关键字virtual实现虚继承

我们在声明可能被作为基类继承的派生类的继承声明时候使用virtual关键字,这样确保在实例化时候只会对Animal进行一次实例化

#include <iostream>

//导入命名空间
using namespace std;

class Animal
{
public:
    int age;
    Animal(){
        cout << "执行了Animal的构造函数" << endl;
    }
};

class AquaticAnimal : public virtual Animal
{
public:
    AquaticAnimal(){
        cout << "执行了AquaticAnimal的构造函数" << endl;
    }
};

class TerrestrialAnimal: public virtual Animal
{
public:
    TerrestrialAnimal(){
        cout << "执行了TerrestrialAnimal中的构造函数" << endl;
    }
};

class Amphibia : public AquaticAnimal, public TerrestrialAnimal
{
public:
    Amphibia(){
        cout << "执行了Amphibia中的构造函数" << endl;
    }
};

int main(){
    Amphibia aAmphibia;
    return 0;
}

编译之后运行得到如下结果

jackwang@jwang:~/桌面/TryC++$ ./TryPloymorphism 
>>>
执行了Animal的构造函数
执行了AquaticAnimal的构造函数
执行了TerrestrialAnimal中的构造函数
执行了Amphibia中的构造函数

这个时候就可以使用语句aAmphibia.age来对age属性进行操作

使用关键字override来表明覆盖意图

前面我们在派生类中覆盖基类的方法都是通过相同特征值来进行覆盖的

而有的时候我们如果不小心笔误将函数的特征值写错了,那么就不会造成覆盖,例如

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void Swim(){
        cout << "鱼在游泳" << endl;
    }
};

class Tuna : public Fish
{
public:
    void Swim() const {
        cout << "金枪鱼在游泳" << endl;
    }
};

这里我们不小心使用了关键字const,这样虽然对程序的运行没有大碍,但是由于Tuna中的Swim具有特征值const,因此和Fish中的特征值不同

所以实际上不会造成覆盖.

为了解决这种问题,我们可以使用关键字override来声明覆盖意图,这样编译器将在编译时候进行检查,如果没有可被覆盖的值将会报错,例如下面的程序

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void Swim(){
        cout << "鱼在游泳" << endl;
    }
};

class Tuna : public Fish
{
public:
    void Swim() const override
    {
        cout << "金枪鱼在游泳" << endl;
    }
};

int main(){
    return 0;
}

编译报错如下

jackwang@jwang:~/桌面/TryC++$ g++ TryPloymorphism.cpp -o TryPloymorphism
>>>
TryPloymorphism.cpp:17:10: error: ‘void Tuna::Swim() const’ marked ‘override’, but does not override
     void Swim() const override
          ^~~~

而基类中具有可以被覆盖的函数时候就不会报错

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void Swim(){
        cout << "鱼在游泳" << endl;
    }
};

class Tuna : public Fish
{
public:
    void Swim() override
    {
        cout << "金枪鱼在游泳" << endl;
    }
};

int main(){
    return 0;
}

编译成功通过

使用关键字final禁止覆盖函数

我们可以在类中使用关键字final来禁止函数在其派生类中再次被覆盖

#include <iostream>

//导入命名空间
using namespace std;

class Fish
{
public:
    virtual void Swim(){
        cout << "鱼在游泳" << endl;
    }
};

class Tuna : public Fish
{
public:
    void Swim() override final
    {
        cout << "金枪鱼在游泳" << endl;
    }
};

class DeadTuna : public Tuna
{
public:
    void Swim(){
        cout << "死亡的金枪鱼在游泳" << endl;
    }
};

int main(){
    return 0;
}

我们编译的时候会报错,报错信息如下

jackwang@jwang:~/桌面/TryC++$ g++ TryPloymorphism.cpp -o TryPloymorphism
>>>
TryPloymorphism.cpp:26:10: error: virtual function ‘virtual void DeadTuna::Swim()’
     void Swim(){
          ^~~~
TryPloymorphism.cpp:17:10: error: overriding final function ‘virtual void Tuna::Swim()’
     void Swim() override final
          ^~~~

不能将复制构造函数声明为虚函数

我们使用关键字virtual来声明虚函数的时候,表明它将被派生类中的函数覆盖,这种多态行为是在运行阶段实现的

但是由于复制构造函数只是用于创建固定类型的对象,因此不具备多态性

所以C++中不允许将复制构造函数声明为虚函数

鸿神
关注
专栏目录
C++ 虚函数与多态性
Chroniccandy的博客
09-26 2234
多态性 面向对象程序设计中的多态性是指向不同的对象发送同一个消息，不同对象对应同一消息产生不同行为。在程序中消息就是调用函数，不同的行为就是指不同的实现方法，即执行不同的函数体,也可以这样说就是实现了“一个接口，多种方法” ...
C++实验九 多态：虚函数 2.1 模拟银行帐户管理程序（附原创代码）
kwai_popova的博客
07-18 1481
（1）问题描述 创建一个银行账户的继承层次，表示银行的所有客户账户。所有的客户都能在他们的银行账户存钱，取钱，并且账户还可以分成更具体的类型。例如，存款账户SavingsAccount依靠存款生利，支票账户CheckingAccount会对每笔交易（即存款或取款）收取费用。 创建一个类层次，以Account作为基类，SavingsAccount和CheckingAccount作为派生类。 基类Account应该包括一个double类型的数据成员balance，表示账户的余额。该类应当提供三个成员函数。成员函
c++ 多态 虚函数 析构函数 抽象类
tattarrattat的专栏
05-07 6464
1. 析构函数和虚析构函数      如果基类的析构函数是虚的，那么它的派生类的析构函数都是虚的       这将导致：当派生类析构的时候，它的所有的基类的析构函数都将得到调用       否则，只调用派生类的析构函数（这可能导致基类的某些对象没有得到释放）          所以CObject类的析构函数是虚的，所有由它派生的类析构的时候一级一级的进行，不会造成内存泄漏。     无论基类的
C++:虚函数与多态
最新发布
2301_79959126的博客
07-26 736
本文介绍了C++中的虚函数与多态的概念，并介绍了虚函数与多态的实现原理。
C++ 多态，虚函数
erinapple的博客
10-25 251
多态是指使用相同的函数名来访问函数不同的实现方法，即“一种接口，多种方法”，用相同的形式访问一组通用的运算，每个运算可能对应的行为不同。 C++支持编译时多态和运行时多态，运算符重载和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。 运行时多态的基础是基类指针，基类指针可以指向任何派生类对象。 2.虚函数与重载函数的区别：     1）重载函数之间必须在参数的类
C++虚函数（多态性）
hanxiaoyong_的博客
02-05 385
C++的多态性用一句话可以概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，在运行时将会根据对象的实际情况类型来调用相应的函数。 C++的多态性是在程序运行时，依据对象的类型来确认调用哪一个函数，这就是迟绑定。 上代码： #include <iostream.h> class animal { public: ...
（八）C++学习 | 虚函数和多态的基本概念
Skies_的博客
07-11 959
C++学习 | 虚函数和多态的基本概念
C++多态中的动态多态：虚函数(前置要求：掌握C++基本语法)
bai_3525的博客
05-22 327
文章目录概念(复习用)什么是多态什么是虚函数怎么实现(多态)多态代码及讲解(学习用)虚函数工作原理参考 概念(复习用) 什么是多态 多态：在面向对象编程中，一种接口(函数)的多种实现(函数内容，作用域)即为多态；多态分静态和动态；静态是指在编译时就可以确定选择哪种实现，动态是运行时才确定选择哪种实现； 静态有函数重载和泛型编程，如add()根据数据类型重载，在编译时就能选好哪一个；动态是虚函数，比如父类和子类中有同名函数delete_data()，在运行时通过基类指针指向的不同对象来选择到底调用哪个； C+
详细分析C++ 多态和虚函数
08-18
详细分析C++多态和虚函数 在C++中，多态和虚函数是两个紧密相关的概念。多态是指在编程语言中，同一个函数名称可以对应不同的函数实现，这取决于调用函数的对象的类型。虚函数则是C++中实现多态的一种机制，它允许...
C++的多态和虚函数原理
weixin_43455008的博客
02-20 404
多态概念 在我的个人博客,可以获得更好的阅读体验。 什么是多态 多态是面向对象三大特性之一: 封装,继承,多态。 多态指同一个实体同时具有多种形式。 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用派生类中的方法。1 多态可以根据状态确定时间分为: 静态多态 和 动态多态。 静态多态: 编译期确定 动态多态: 运行时确定 为什
C++虚函数和多态
m0_58232069的博客
04-20 267
虚函数和虚函数表 什么是虚函数? 用virtual 修饰的成员函数叫做虚函数 虚函数对于类的影响 增加一个指针的内存，32位4个字节 ，64位就是8个字节 虚函数表(了解一下): 就是一个指针存储所有虚函数的首地址 #include <iostream> using namespace std; class MM { public: virtual void print1() { cout << "虚函数1"<&lt
C++多态（虚函数）
weixin_44117735的博客
08-17 388
文章目录一、多态？二、分类根据实现的时机三、虚函数注意总结 一、多态？ 面向对象程序设计的重要特征之一。（其他两个特征是封装和继承） 多态的本质是指同一个函数的多种形态。 简单的理解就是，同一个函数在调用的时候，不同的行为（输入）就会产生不同的实现方式。 通俗的说就是，你（函数）遇到了红绿灯（不同的行为），你就会根据红绿灯进行相应的动作（不同的实现）。就是说你还是你，但是当遇到红绿灯的时候，根据灯的状态（红 或者 绿 或者 黄），你会有不同的动作（停止 或者 行走 或者 减速）。 正式的书面表达，..
C++ 多态性——虚函数
NuYoaH502329的博客
08-08 1054
运行过程中的多态需要满足3个条件：（1）类之间满足类型兼容规则（2）要声明虚函数（3）要由成员函数来调用或者通过指针、引用来访问虚函数【注意】虚函数一般不声明为内联函数，因为对虚函数的调用需要动态绑定，而对内联函数的处理是静态的，所以虚函数一般不能以内联函数来处理。但将虚函数声明为内联函数也不会引起错误，因为编译器会自动忽略。
C++—虚函数和多态
kk阿彬
07-06 745
文章目录虚函数和多态纯虚函数和抽象类多态的实现原理：虚函数表 虚函数和多态 我们直观上认为，如果指针指向了派生类对象，那么就应该使用派生类的成员变量和成员函数，但是实际是，当基类指针 p 指向派生类的对象时，只可以使用成员变量，不能使用派生类的成员函数 即：通过基类指针只能访问派生类的成员变量，但是不能访问派生类的成员函数。 为了让基类指针能够访问派生类的成员函数，C++ 增加了虚函数（Virtual Function） 虚函数和普通函数的区别： 普通函数是根据指针的类型来调用的，哪个类定义的指针就调用哪
C++ 虚函数和多态
virgilshi的博客
06-09 144
参考文献 https://zhuanlan.zhihu.com/p/37340242 https://www.runoob.com/cplusplus/cpp-inheritance.html C++ 虚函数和多态 网上介绍虚函数的内容非常多，我不在赘述周知的内容，本博客作为个人笔记，因此记录我体会的一些用法。时间：2019年6月9日22:16:26 虚函数，virtual，一般来接口和抽象类...
c++ 虚函数和多态性
nauty的专栏
05-11 1274
      开始之前，我们首先假设这样一组形状类。Shape,Point,Circle很明显，它们有着Shape1、虚函数       简单的说，虚函数就是在函数原型前加上virtual关键字。函数一旦被声明为虚函数，即使类在改写它的时候没有将其声明为虚函数，它从该点的继承层次结构中仍然是虚函数。如果基类中一个函数被声明为虚函数，在若干子类中有着不同的实现，那么我们在创建若干子类的不同对象
C++的虚函数、多态性
qq_33185566的博客
03-04 253
实现多态的三个条件： （1）要有继承 （2）要有虚函数重写 （3）用父类指针（父类引用）指向子类对象（Parent *p = new Child） 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 首先我们定义两个类： class Animal { pub...
C++多态详解：虚函数实现与原理示例
1. 虚函数：C++中的多态起始于虚函数的定义。使用`virtual`关键字声明的函数被称为虚函数，它是类的成员函数，可以在派生类中被重写。虚函数的目的是为了实现运行时多态性。 2. 虚表与虚指针：每个包含虚函数的类都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值