C++多态

已于 2023-03-19 01:32:44 修改
阅读量269 收藏
点赞数 1
分类专栏： C/C++程序设计教程 文章标签： c++ 开发语言 c语言 Powered by 金山文档
于 2023-03-18 23:07:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d704791892/article/details/129624189
版权
本文介绍了C++中的多态性，包括静态多态（如函数重载）和动态多态（通过虚函数实现）。动态多态使得子类对象通过父类指针或引用调用相应的方法时，能够执行不同的实现。文章还讨论了虚函数表、抽象类以及虚析构函数的概念，强调了它们在多态和内存管理中的作用。
摘要由CSDN通过智能技术生成
在现实生活中，不同事物的同一种行为或动作，在细节上的表现可能是不一样的。比如人类，在说话这个行为上，中国人用的是汉语，英国人用的是英语，韩国人用的是韩文等。
在计算机编程语言中， 多态（polymorphism）指的是为不同数据类型的实体提供统一的接口，C++也支持多态特性。利用多态特性提供统一接口来描述以上所说的现实中的不同事物的同一种行为或动作，但在细节上的表现又可能不一样。
多态的种类

静态多态：函数重载，操作符重载，就属于静态多态。函数名相同，在相同参数个数的条件下，函数的参数类型不同，或参数的类型顺序不同，或函数参数的个数不同。注意：函数参数的返回值不同是不能作为函数重载的条件的。

动态多态：父类的成员函数声明为虚函数或纯虚函数，子类重写父类的虚函数或纯虚函数，在使用时，让子类的对象指向父类的引用或指针，从而实现运行时多态。

在C++面向对象编程中，我们说的多态，一般指的就是动态多态。

静态多态和动态多态的区别

静态多态函数地址是早绑定，编译阶段确认函数地址。

动态多态函数地址是晚绑定，运行阶段确定函数地址。

语法规则

虚函数语法

virtual 函数返回值 成员函数名(参数列表) {}

纯虚函数语法

virtual 函数返回值 成员函数名(参数列表) = 0;

1.动态多态举例：将父类的成员函数声明为虚函数，子类重写父类的虚函数

#include <iostream>
using namespace std;

class People
{
    public:
    virtual void speak() const //虚函数
    {
        cout << "人在说话" << endl;
    }
};

class Chinese : public People
{
    public:
    virtual void speak() const //重写父类的虚函数
    {
        cout << "中国人在用汉语说话" << endl;
    }
};

class British : public People
{
    public:
    virtual void speak() const //重写父类的虚函数
    {
        cout << "英国人在用英文说话" << endl;
    }
};

void peopleSpeak(const People &p)
{
    p.speak();
}

void peopleSpeak(const People *p)
{
    p->speak();
}

int main(int argc, char * argv[])
{
    Chinese c;
    peopleSpeak(c); //子类对象指向父类的引用
    peopleSpeak(&c); //子类对象指向父类的指针

    British b;
    peopleSpeak(b); //子类对象指向父类的引用
    peopleSpeak(&b); //子类对象指向父类的指针

    cout << "sizeof(People) = " << sizeof(People) << endl;
    cout << "sizeof(Chinese) = " << sizeof(Chinese) << endl;
    cout << "sizeof(British) = " << sizeof(British) << endl;
    return 0;
}

分析：C++中，空类占用内存大小为1字节。类的成员变量和成员函数是分开存储的，只有非静态成员变量才存储在类中或类的对象上。通过该类创建的所有对象都共享同一个函数。但我们打印出的只含有一个虚函数的People，Chinese，British类占用了8个字节。这是为什么呢？本质是因为：含有虚函数，纯虚函数的类会有一个虚函数表指针，这个虚函数指针指向虚函数表。因为我编译的是64位可执行程序，一个函数指针的内存大小为8字节，所以打印出含有虚函数的People，Chinese，British类的内存大小是8个字节

2.动态多态举例：将父类的成员函数声明为纯虚函数，子类重写父类的纯虚函数

#include <iostream>
using namespace std;

class People
{
    public:
    virtual void speak() const = 0; //纯虚函数
};

class Chinese : public People
{
    public:
    virtual void speak() const //重写父类的纯虚函数
    {
        cout << "中国人在用汉语说话" << endl;
    }
};

class British : public People
{
    public:
    virtual void speak() const //重写父类的纯虚函数
    {
        cout << "英国人在用英文说话" << endl;
    }
};

void peopleSpeak(const People &p)
{
    p.speak();
}

void peopleSpeak(const People *p)
{
    p->speak();
}

int main(int argc, char * argv[])
{
    Chinese c;
    peopleSpeak(c); //子类对象指向父类的引用
    peopleSpeak(&c); //子类对象指向父类的指针

    British b;
    peopleSpeak(b); //子类对象指向父类的引用
    peopleSpeak(&b); //子类对象指向父类的指针

    cout << "sizeof(People) = " << sizeof(People) << endl;
    cout << "sizeof(Chinese) = " << sizeof(Chinese) << endl;
    cout << "sizeof(British) = " << sizeof(British) << endl;

    return 0;
}

抽象类

含有纯虚函数的类称为抽象类。

抽象类的特点：

  1. 无法实例化

  1. 子类必须重写抽象类中的纯虚函数，否则这个子类还是抽象类

  1. 抽象类虽然不能实例化，但抽象类的虚函数表指针是存在的

#include <iostream>
using namespace std;

class People
{
    public:
    virtual void speak() const = 0; //纯虚函数
};

int main(int argc, char * argv[])
{
    //People p; //错误：抽象类不能实例化
    cout << "sizeof(People) = " << sizeof(People) << endl; //sizeof(People) = 8

    return 0;
}
虚析构函数和纯虚析构函数

在C++中使用多态时，如果在堆区new子类对象指向父类指针，那么父类指针在释放时，是调用不到子类的析构函数的，为了解决这个问题，需要把父类的析构函数定义为虚析构函数或纯虚析构函数。

虚析构函数语法

virtual ~类名(){}

纯虚析构函数

virtual ~类名() = 0; //类内声明
类名::~类名(){} //类外必须实现

含有纯虚析构函数的类也是抽象类，无法实例化对象

  1. 举例：堆区new子类对象指向父类指针，那么父类指针在释放时，是调用不到子类的析构函数

#include <iostream>
using namespace std;

class People
{
    public:
    ~People()
    {
        cout << "~People()" << endl;
    }
    virtual void speak() const = 0; //纯虚函数
};

class Chinese : public People
{
    public:
    ~Chinese()
    {
        cout << "~Chinese()" << endl;
    }
    virtual void speak() const //重写父类的纯虚函数
    {
        cout << "中国人在用汉语说话" << endl;
    }
};

class British : public People
{
    public:
    ~British()
    {
        cout << "~British()" << endl;
    }
    virtual void speak() const //重写父类的纯虚函数
    {
        cout << "英国人在用英文说话" << endl;
    }
};

void peopleSpeak(const People &p)
{
    p.speak();
}

void peopleSpeak(const People *p)
{
    p->speak();
}

int main(int argc, char * argv[])
{
    People *p = new Chinese;
    peopleSpeak(*p); //子类对象指向父类的引用
    peopleSpeak(p); //子类对象指向父类的指针
    delete p;
    p =NULL;

    p = new British;
    peopleSpeak(*p); //子类对象指向父类的引用
    peopleSpeak(p); //子类对象指向父类的指针
    delete p;
    p = NULL;

    return 0;
}

  1. 举例：将父类的析构函数定义为虚析构函数，解决通过父类指针释放子类对象调用不到子类的析构函数的问题

#include <iostream>
using namespace std;

class People
{
    public:
    virtual ~People() //将父类的析构函数定义为虚析构函数
    {
        cout << "~People()" << endl;
    }
    virtual void speak() const = 0; //纯虚函数
};

class Chinese : public People
{
    public:
    virtual ~Chinese()
    {
        cout << "~Chinese()" << endl;
    }
    virtual void speak() const //重写父类的纯虚函数
    {
        cout << "中国人在用汉语说话" << endl;
    }
};

class British : public People
{
    public:
    virtual ~British()
    {
        cout << "~British()" << endl;
    }
    virtual void speak() const //重写父类的纯虚函数
    {
        cout << "英国人在用英文说话" << endl;
    }
};

void peopleSpeak(const People &p)
{
    p.speak();
}

void peopleSpeak(const People *p)
{
    p->speak();
}

int main(int argc, char * argv[])
{
    People *p = new Chinese;
    peopleSpeak(*p); //子类对象指向父类的引用
    peopleSpeak(p); //子类对象指向父类的指针
    delete p;
    p =NULL;

    p = new British;
    peopleSpeak(*p); //子类对象指向父类的引用
    peopleSpeak(p); //子类对象指向父类的指针
    delete p;
    p = NULL;

    cout << "sizeof(People) = " << sizeof(People) << endl;
    cout << "sizeof(Chinese) = " << sizeof(Chinese) << endl;
    cout << "sizeof(British) = " << sizeof(British) << endl;

    return 0;
}

  1. 举例：将父类的析构函数定义为纯虚析构函数，解决通过父类指针释放子类对象调用不到子类的析构函数的问题

#include <iostream>
using namespace std;

class People
{
    public:
    virtual ~People() = 0; //将父类的析构函数声明为纯虚析构函数
    virtual void speak() const = 0; //纯虚函数
};

People::~People() //类外必须初始化
{
        cout << "~People()" << endl;
}

class Chinese : public People
{
    public:
    virtual ~Chinese()
    {
        cout << "~Chinese()" << endl;
    }
    virtual void speak() const //重写父类的纯虚函数
    {
        cout << "中国人在用汉语说话" << endl;
    }
};

class British : public People
{
    public:
    virtual ~British()
    {
        cout << "~British()" << endl;
    }
    virtual void speak() const //重写父类的纯虚函数
    {
        cout << "英国人在用英文说话" << endl;
    }
};

void peopleSpeak(const People &p)
{
    p.speak();
}

void peopleSpeak(const People *p)
{
    p->speak();
}

int main(int argc, char * argv[])
{
    People *p = new Chinese;
    peopleSpeak(*p); //子类对象指向父类的引用
    peopleSpeak(p); //子类对象指向父类的指针
    delete p;
    p =NULL;

    p = new British;
    peopleSpeak(*p); //子类对象指向父类的引用
    peopleSpeak(p); //子类对象指向父类的指针
    delete p;
    p = NULL;

    cout << "sizeof(People) = " << sizeof(People) << endl;
    cout << "sizeof(Chinese) = " << sizeof(Chinese) << endl;
    cout << "sizeof(British) = " << sizeof(British) << endl;

    return 0;
}

关于C++多态的知识点梳理以及使用，先写到这，后面有空再写一篇C++多态的内存模型，让我们更加深层次的去了解C++多态的实现原理。

微尘8
关注
专栏目录
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
C++中的接口有什么用
m0_61629312的博客
12-13 919
2023年12月13日，周三上午今天上午在适配器模式，我发现如果想真正理解适配器模式，就必须学会使用C++中的接口，就必须明白为什么要在C++中使用接口，所以重新学习了一下C++中的接口。
c++的多态（一个接口，多种实现）
weixin_43293737的博客
01-14 1873
为什么要使用多态？为了解决同一段代码在不同的对象调用时有不同的效果，避免了代码的冗余 实现多态的三个条件： 1 要有继承 2 要有虚函数重写 3 用父类指针(父类引用)指向子类对象… #include &quot;iostream&quot; using namespace std; class animal { public: virtual int eat() { return 10; } }; cla...
c++ 使用枚举类型统一接口
wonengguwozai的博客
03-27 693
背景：提供的算法库包含不同子算法：人脸跟踪和目标跟踪，两个算法提供的接口（返回的结果）中均提供跟踪状态值（正在跟踪，目标暂时丢失，等等多个值）可供上层调用算法库使用（不同算法的统一跟踪状态对上层的作用是一致的）。但在两个算法内部定义不同跟踪状态所使用的值是不统一的，如目标跟踪使用1代表正在跟踪，人脸跟踪使用0代表正在跟踪。这样上层在调用算法库时需要根据不同算法判断每个值代表什么状态，这样给上层调...
C++向Lua传递多种数据类型的统一接口
牧羊女
05-27 568
有时候我们需要通过C++向Lua传递包含多种类型数据的参数，但这些参数又没办法提前预知，也就是说，应用可能会有不同类型的参数，这些参数需要统一传入Lua进行处理。很显然，如果每次都要去判断每一个参数的类型，并调用不同的传递函数lua_push***，在代码上就显得拖沓冗余，并且效率低下。那么有没有办法定义一个统一的接口，能够接收常用的数据类型，并统一传给Lua呢？ 可以利用类的多态性实现。 假如我们传递的数据类型包括int、double、bool、string，那么，让我们来定义一个基类和若干子类。
C++的精髓——代码复用、接口复用
浮城大亨的专栏
09-28 4635
C++的精髓——代码复用、接口复用 在另一篇文章中提到C++三大特点的核心概括，也写在这里吧。 封装：信息隐藏 继承：代码复用 多态：面向对象 C++并不是面向对象，它包容多种编程思想，如面向过程，面向对象，泛型编程等。 笔者还在学校的时候理解C++最终精髓是两点：代码复用、接口复用。到现在隔的时间挺长了，今天不防把它记录下来，希望不会引起各位高手的嘲笑吧。 C++的特点
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
C++ 多态和虚函数 高清PDF
08-15
多态性（在C + +中用虚函数实现）是面向对象程序设计语言继数据抽象和继承之后的第三个基本特征。 它提供了与具体实现相隔离的另一类接口，即把“ w h a t”从“h o w”分离开来。多态性提高了代码的组织性和可读性...
C++中的接口与实现
热门推荐
Studing In Depth
08-26 1万+
C++中的接口与实现         所谓接口继承，就是派生类只继承函数的接口，也就是声明；而实现继承，就是派生类同时继承函数的接口和实现。        我们都很清楚C++中有几个基本的概念，虚函数、纯虚函数、非虚函数。        虚函数：        C++实现
C++与QML的数据交互
qq_50679120的博客
09-11 462
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 235
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 868
set、map仿STL模拟实现
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 430
继续学习头文件的数学函数。
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 728
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
【C++ && Qt day11】
wzj46的博客
09-11 252
2、头文件窗口文件。
CCF201903_1
最新发布
m0_67663419的博客
09-14 123
【代码】CCF201903_1。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1019
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
c++ 多态
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为编译时多态。C++中实现静态多态的方式主要有函数重载和运算符重载。 函数重载是指在同一作用域内定义多个同名函数，但它们的参数列表不同。编译器根据传递给函数的参数类型和数量来确定调用哪个函数。例如： ```c++ void print(int num) { std::cout << "This is an integer: " << num << std::endl; } void print(double num) { std::cout << "This is a double: " << num << std::endl; } int main() { int a = 10; double b = 3.14; print(a); // 调用第一个print函数 print(b); // 调用第二个print函数 } ``` 运算符重载是指对C++中的运算符进行重新定义，使其能够用于自定义的数据类型。例如： ```c++ class Complex { public: Complex(double real, double imag) : m_real(real), m_imag(imag) {} Complex operator+(const Complex& other) const { return Complex(m_real + other.m_real, m_imag + other.m_imag); } private: double m_real; double m_imag; }; int main() { Complex a(1.0, 2.0); Complex b(3.0, 4.0); Complex c = a + b; // 调用Complex类中重载的+运算符 } ``` 2. 动态多态 动态多态是指在运行时根据对象的实际类型来确定调用哪个函数，也称为运行时多态。C++中实现动态多态的方式主要有虚函数和纯虚函数。 虚函数是在父类中定义的可以被子类重写的函数，使用virtual关键字声明。当一个对象的指针或引用指向一个子类对象时，调用虚函数时会根据实际的对象类型来确定调用哪个函数。例如： ```c++ class Shape { public: virtual void draw() { std::cout << "Drawing a shape." << std::endl; } }; class Circle : public Shape { public: void draw() override { std::cout << "Drawing a circle." << std::endl; } }; int main() { Shape* shape_ptr = new Circle(); shape_ptr->draw(); // 调用Circle类中重写的draw函数 } ``` 纯虚函数是在父类中定义的没有实现的虚函数，使用纯虚函数声明（如virtual void func() = 0;）。父类中包含纯虚函数的类称为抽象类，抽象类不能被实例化，只能作为基类来派生子类。子类必须实现父类的纯虚函数才能实例化。例如： ```c++ class Shape { public: virtual void draw() = 0; }; class Circle : public Shape { public: void draw() override { std::cout << "Drawing a circle." << std::endl; } }; int main() { Shape* shape_ptr = new Circle(); shape_ptr->draw(); // 调用Circle类中重写的draw函数 } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值