c++ 如何实现多态

多态性 - C++中实现运行时多态的方式 C++中的多态性是指同一个函数可以有多种不同的实现方式,并且在运行时根据实际情况进行选择执行。在C++中实现多态有两种方式:静态多态和动态多态。静态多态是指在编译时确定函数的实现,包括函数重载和模板函数;动态多态是指在运行时根据对象的实际类型来确定函数的实现,包括虚函数和抽象类。本文介绍了C++中实现运行时多态的两种方式:静态多态和动态多态。静态多态包括函数重载和模板函数,动态多态包括虚函数和抽象类。通过对这些知识点的学习,可以更好地理解C++中的多态性,更灵活地应用在实际的程序开发中。 阅读详情
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>

using std::cerr;
using std::cout;
using std::string;

//实覆盖
class A1
...{
public:
    A1(string const& name) : m_Name(name) ...{cout << getName() << "A1::A1() ";}
    ~A1() ...{cout << getName() << "A1::~A1() ";}
    void print() const ...{cout << getName() << "A1::print() ";}
protected:
    string const& getName() const ...{return m_Name;}
private:
    string m_Name;
};

class A2 : public A1
...{
public:
    A2(string const& name) : A1(name) ...{cout << getName() << "A2::A2() ";}
    ~A2() ...{cout << getName() << "A2::~A2() ";}
    void print() const ...{cout << getName() << "A2::print() ";}
};

//虚覆盖
class B1
...{
public:
    B1(string const& name) : m_Name(name) ...{cout << getName() << "B1::B1() ";}
    virtual ~B1() ...{cout << getName() << "B1::~B1() ";}
    virtual void print() const ...{cout << getName() << "B1::print() ";}
protected:
    string const& getName() const ...{return m_Name;}
private:
    string m_Name;
};

class B2 : public B1
...{
public:
    B2(string const& name) : B1(name) ...{cout << getName() << "B2::B2() ";}
    virtual ~B2() ...{cout << getName() << "B2::~B2() ";}
    virtual void print() const ...{cout << getName() << "B2::print() ";}
};

//虚覆盖,并使用实析构函数(这是个错误)
class C1
...{
public:
    C1(string const& name) : m_Name(name) ...{cout << getName() << "C1::C1() ";}
    ~C1() ...{cout << getName() << "C1::~C1() ";}
    virtual void print() const ...{cout << getName() << "C1::print() ";}
protected:
    string const& getName() const ...{return m_Name;}
private:
    string m_Name;
};

class C2 : public C1
...{
public:
    C2(string const& name) : C1(name) ...{cout << getName() << "C2::C2() ";}
    ~C2() ...{cout << getName() << "C2::~C2() ";}
    virtual void print() const ...{cout << getName() << "C2::print() ";}
};

//分开各部分的输出
void printLine(unsigned int height = 1, unsigned int length = 20,
                char ch = '-', std::ostream& out = cout)
...{
    const string LINE(length, ch);

    for (; height != 0; --height)
    ...{
    //在out上输出一行ch
        std::copy(LINE.begin(), LINE.end(), std::ostream_iterator<char>(out));
        out << ' ';
    }
}

//测试
int main()
...{
    try
    ...{
    //实覆盖
        cout << "Real override 1: ";
        ...{
            printLine();
            A1 a1("a1.");
            printLine();
            A2 a2("a2.");
            printLine(2);

            a1.print();
            printLine();
            a2.print(); //调用的是a2.A2::print()
            printLine();
            static_cast<A1>(a2).print();
            //上句调用A1::A1(A1&)或A1::A1(A1 const&)生成一个临时的A1类的变量
            //然后这个临时变量调用A1::print()
            //在脱离作用域后(该语句结束时)将调用A1::~A1()
            //其余见注释4
            printLine();
            a2.A1::print(); //不同于上句,此处不调用析构函数

            printLine(2);
        } //超出作用域,调用析构函数;下面也按照同样的格式使用花括号

        printLine(3);

        //使用指针实现实覆盖,可能会产生错误
        cout << "Real override 2: ";
        ...{
            printLine();
            A1* pa1 = new A1("pa1->");
            printLine();
            A1* pa2 = new A2("pa2->"); //注意是基类的指针
            printLine();
            A2* pa3 = new A2("pa3->");
            printLine();
            A2 a4("a4.");
            A1* pa4 = &a4; //注意是基类的指针
            A1& ra2 = *pa2; //注意是基类的引用   
            printLine(2);

            pa1->print(); //未检查指针,因为出错时new会抛出异常
            printLine();
            pa2->print(); //调用的是pa2->A1::print()
            printLine();
            pa3->print(); //调用的是pa3->A2::print()
            printLine();
            pa4->print(); //调用的是a4.A1::print(),即pa4->A1::print()
            printLine();
            ra2.print();
            printLine(2); //调用的是pa2->A1::print()

            delete pa1;
            printLine();
            delete pa2; //错误,(*pa2).A2::~A2()不会被调用
            printLine();
            delete pa3;
            printLine();
            pa1 = NULL;
            pa2 = NULL;
            pa3 = NULL;
            pa4 = NULL; //pa4不是new出来的,不用delete
        }

        printLine(3);

        //下面不再重复实覆盖中一些相同的测试

        //虚覆盖
        cout << "Virtual override 1: ";
        ...{
            printLine();
            B1 b1("b1.");
            printLine();
            B2 b2("b2.");
            printLine();

            b1.print();
            printLine();
            b2.print(); //调用的是b2.B2::print(),同实函数一样
            printLine();
        }

        printLine(3);

        cout << "Virtual override 2: ";
        ...{
            printLine();
            B1* pb1 = new B1("pb1->");
            printLine();
            B1* pb2 = new B2("pb2->"); //注意是基类的指针
            printLine();
            B1& rb2 = *pb2; //注意是基类的引用
            printLine();

            pb1->print();
            printLine();
            pb2->print(); //调用的是pb2->B2::print()
            printLine();
            rb2.print(); //调用的是pb2->B2::print()
            printLine();

            delete pb1;
            printLine();
            delete pb2;
            pb1 = NULL;
            pb2 = NULL;
        }

        printLine(3);

        //虚覆盖,并使用实析构函数(这是个错误)
        cout << "Virtual override 1, using real destruction: ";
        ...{
            printLine();
            C1 c1("c1.");
            printLine();
            C2 c2("c2.");
            printLine(2);

            c1.print();
            printLine();
            c2.print();
            printLine(2);
        }

        printLine(3);

        cout << "Virtual override 2, using real destruction: ";
        ...{
            printLine();
            C1* pc1 = new C1("pc1->");
            printLine();
            C1* pc2 = new C2("pc2->"); //注意是基类指针
            printLine(2);

            pc1->print();
            printLine();
            pc2->print(); //pc2->C2::~C2()不会被调用
            printLine(2);

            delete pc1;
            printLine();
            delete pc2;
            cout << std::endl;
            pc1 = NULL;
            pc2 = NULL;
        }

        return 0;
    }
    catch (std::bad_alloc&)
    //如果内存不够,new抛出std::bad_alloc
    //似乎在VC++下永远不会抛出该异常,但也不会出错;在g++等编译器中则会抛出该异常
    ...{
        cerr << " No enough memory! ";
        return 1;
    }

    catch (...)
    ...{
        cerr << " 发现未知异常,也许你人品有问题。";
        return 2;
    }
}

结论:

1.通过对象直接调用成员函数时,始终默认使用该对象的类的成员函数(除非用::显示指定类名)。

2.通过指向对象的指针或引用调用成员函数时:
如果该函数是实函数,则调用该指针或引用的类的成员函数;
如果该函数是虚函数,则调用该指针或引用指向的对象的类的成员函数。

3.基类析构函数在此情况下必须为虚函数(此时,其派生类的析构函数也将是虚函数):
用new来创建派生类对象,并且delete时使用的指针为基类的指针。
若为实析构函数,则派生类部分的成员将不会被析构。

4.若未定义复制构造函数,不要将一个派生类对象强制类型转换为基类对象。
因为若未显式定义复制构造函数,则编译器会生成一个默认的复制构造函数。
然而这个默认的复制构造函数将不会做你希望做的其他的事,如:
如果要在构造函数中维护一个类对象的计数器,则这个函数不会导致计数器增加;
如果要在构造函数中new一个对象,则这个函数也不会new该有的对象。
这个默认的复制构造函数进行的是浅拷贝,使用的成员都是原来的对象的。
因此这个临时对象在析构时,delete的是原来的对象new出来的对象;
而原来的对象在析构时将再次delete这个对象;这属于未定义行为,可能引起程序崩溃。
并且,即使在析构函数中,在delete这个对象后,将指向这个对象的指针赋值为NULL也无效;
因为更改的是临时对象的指针,而原对象的指针仍指向那个被delete了的对象。

关于第4点的结论,我实际上是写了另一个测试代码证明的。
不过那个测试代码在最后一次测试时被我改得太乱了,就不给出了。
有兴趣的可以将A1和A2类添加静态的对象计数器、对象指针和复制构造函数,再自己去研究。
我在VC++6.0 SP6上测试时,debug和release模式下运行状态居然不同(前者崩溃,后者看上去正常)。
然而我一直没太多时间好好研究它,问了好多人却没人给出正确回答。
最后我只好自己跟踪反汇编代码了。能得出上述的结论,还得感谢VC++的调试器。

附:原理阐述

c++的编译器是怎么识别这个指针指向派生类的对象的?
例如:
class A {
   int i;
   int j;
   virtual void function(){
       cout<<"this is class a"<<endl;
   }
  
};

class B :public A
{ 
   int k;
   void function()
   {
      cout<<"this is class b"<<endl;
    }
};


void main()
{
    A* pa;
    A a;
    pa=&a;
    pa->function();

    B b;
    pa=&b;
    pa->function();
}
类A的对象块的空间大小是和类B的对象块的大小一样吗?

 

类A的对象块的空间大小和类B的对象块的空间大小不一样。就此代码,32位
环境中,A的对象12字节(两个int一个虚表指针),B的对象16字节(三个int一个
虚表指针)。

把&b赋值给pa之前,b的空间已经分配好了16字节。所谓“把&b赋值给pa”,只
不过是把那16字节的首地址保存在pa中,所以把&b赋值给pa之后,pa指向的空间
大小是16字节,而不是12字节。只是因为pa的类型为A*,所以用pa->的形式只可以
访问到b中属于从A继承的部分,而不能访问到B增加的部分。

通过指针访问成员实际上要计算一个该成员在对象中的偏移。然后用指针中的地址
加上这个偏移就访问到了成员。
 
虚函数的实质是每个对象中有一个指针 ,指向一个表,表中依次存放了虚函数的地址。
这个表我们叫他虚表。
 当我们用pa->function();这样的形式调用一个虚函数,编译器实际上隐式做了一些
 转换,先通过虚表指针找到虚表,再在虚表中找到虚函数指针,最后通过虚函数指针
 调用虚函数。

 一个虚函数指针在基类的虚表中的位置和  在派生类的虚表中的位置是相同的。派生类
 改写一个虚函数意味着增加一段函数代码,同时派生类的虚表中对应的虚函数指针更改
 为指向新增加的代码。

 指针的类型只是决定了访问成员时计算偏移的方式和大小,而指针不管指向基类还是派生
 类,调用一个虚函数所需要的偏移是一样的,只是内容不一样,从而导致不同的形为。

【PLC】三菱plc控件安装 component Movedata had the following error ... Error Number:-119 Windows 10 专业版/企业版本版本号:22H2操作系统内部版本:19045.3448。 阅读详情

相关推荐

2D激光slam数据集的下载与测试

参考博客: https://blog.youkuaiyun.com/qq_24894159/article/details/81265991 https://blog.youkuaiyun.com/fk1174/article/details/52673413#commentBox 数据集下载与生成 下载数据集 下载网址: http://ais.informatik.uni-freiburg.de/slamevaluation/datasets.php 进去网站后点你想下载的对应的"download log file" 然后你

老李的博客 4027

C++多态的实现

本篇文章主要介绍了C++虚函数、动态析构、纯虚函数与抽象类的实现

qq_51024622的博客 5646

哨兵2植被参数反演避坑指南:SNAP中10m/20m分辨率选择与缺失波段处理

本文深入解析了使用SNAP软件进行哨兵2号植被参数反演时的关键操作与决策。核心在于理解SNAP生物物理处理器NNET10m与NNET20m的架构差异,根据是否需要反演冠层叶绿素含量(Cab)等参数,明智选择10米或20米分辨率工作流。文章详细指导了大气校正、波段重采样及处理L2A数据中B01波段“缺失”等常见问题的解决方案,为生态监测与精准农业应用提供清晰的避坑指南和完整实战流程。

wdx01234567的博客 262

C++的各种多态及其实现方法

C++的各种多态及其实现方法

weixin_44014982的博客 1977

gtsam官方文档: The new IMU Factor学习笔记

gtsam官方文档:The new IMU Factor 本文为gtsam imu预积分文档学习笔记,为gtsam基于切向量实现的imu预积分的理论基础。 导航状态 定义导航状态为 Xbn={Rbn,Pbn,Vbn}X^n_b=\{R^n_b,P^n_b,V^n_b\}Xbn​={Rbn​,Pbn​,Vbn​} 上角标n:导航(navigation)坐标系 下角标b:载体(body)坐标系 下文均省略上下标 矢量场与微分方程 对于导航问题我们用如下微分方程描述 X˙(t)=F(t,X)\dot X(t)

南柯一梦的博客 1612

BMS应用软件开发 — 7 从特斯拉到问界:主流BMS硬件架构深度解析

本文深度解析了从特斯拉Model 3到问界M5的主流BMS硬件架构,探讨了BMS在电动汽车中的核心价值与应用软件开发的关键技术。通过对比分析两家厂商的硬件设计哲学、芯片选型策略及成本控制方法,揭示了BMS硬件系统如何影响电池性能与整车安全。文章特别分享了电压采样精度、EMC设计等实战经验,为BMS开发提供宝贵参考。

weixin_42554408的博客 458

C/C++中的多态理解

定义 多态的定义简单来说就是使一条语句有多种状态。 实现方式 多态的实现方式分为三块:重载、重写、重定义。下面我们来谈一谈他们各自的实现方式和实现原理。 重载 实现方式 重载是在同一作用域内(不管是模块内还是类内,只要是在同一作用域内),具有相同函数名,不同的形参个数或者形参类型。返回值可以相同也可以不同(在函数名、形参个数、形参类型都相同而返回值类型不同的情况下无法构成重...

Lynnllh的博客 1万+

详解AXI4-Lite接口(3)--AXI4-Lite接口IP源码仿真及分析(Master接口)

通过本文您会学到:1、了解AXI4-Lite_Master接口的逻辑实现;2、加深Xilinx IP、仿真工具的使用;3、提高阅读时序图的能力。

孤独的单刀 6448

C++多态的实现及原理详细解析

C++的多态性用一句话概括就是: 在基类的函数前加上virtual关键字,在派生类中重写该函数,运行时将会根据对象的实际类型来调用相应的函数。 如果对象类型是派生类,就调用派生类的函数;如果对象类型是基类,就调用基类的函数,此为多态的表现; 在看看以下几点: 1. 用virtual关键字申明的函数叫做虚函数,虚函数肯定是类的成员函数。 2. 存在虚函数的类都有一个一维的虚函数表叫...

weixin_30781775的博客 1816

Open3D (C++) 计算点云坐标最值及其索引

使用C++版本的Open3D计算点云最值点及其对应的下标索引

点云侠的博客 731

YOLO26优化:AAAI2026 | 融合PartialNet Block的C3k2-YOLO高效目标检测网络 | 轻量化涨点设计

PartialNet Block 结合YOLO26的C3k2模块,进行二次创新。

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 597

cpp中的多态及其实现原理自述

用于自我学习和成长

Template Code 1449

论文工具——写论文好用的绘图工具(甘特图+流程图+网络模型图+泳道图)

* 在写HiFi-GAN论文的代码阅读过程中,我发现仅仅通过文字来描述网络结构,不够详细,所以想绘制出网络结构图,更加具象化的描述出网络结构。想去花了,才发现之前都是通过在线绘图网站画的,费时费力,所以想找一些专门的网站化出比较规范并且高质量的图。一方面是为了方便讲解,提高论文的质量,另外一方面也是为了以后写论文打下良好的基础。 * 这篇文章会根据我以前的画图经验展开,以前是使用绘图软件,手动绘图。后来,看到了其他的方法,但是需要写一些代码,或者需要安装特定的软件,投入成本太大,就没有学。所以,本文分享的工

Blackoutdragon的博客 1万+

C++ 多态的定义及实现

C++ 多态的定义及实现 1. 多态定义的构成条件 多态是在不同继承关系的类对象,去调同一函数,产生了不同的行为。 就是说,有一对继承关系的两个类,这两个类里面都有一个函数且名字、参数、返回值均相同,然后我们通过调用函数来实现不同类对象完成不同的事件。 但是构成多态还有两个条件: 调用函数的对象必须是指针或者引用。 被调用的函数必须是虚函数,且完成了虚函数的重写。 说了这么多,怎么实现呢?我们...

Gerald的博客 7万+

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

C++多态的实现方式

编译时多态(函数重载和模板)提供了高度的灵活性和类型安全,且没有运行时开销,但它们在需要动态类型判断的场景中力不从心。运行时多态(基于继承的虚函数、函数指针)允许程序在运行时根据对象类型做出决策,非常适合需要灵活扩展和动态行为的系统,但可能带来一定的运行时开销。CRTP结合了模板和静态多态,提供了类似动态多态的行为,同时避免了虚函数表的开销,适用于性能敏感且需要静态类型检查的场景。

红军不怕远征难,万水千山只等闲 1934

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

[C++]——多态实现原理

多态实现原理

weixin_50720782的博客 1930

C++多态的实现原理详解

C++多态的实现原理详解

嗨,欢迎来到我的 优快云 博客小天地!一名深耕多年的技术发烧友。在这里,我将把日常工作中积累的宝贵经验,从复杂架构设计的精妙之处,到代码优化的实战技巧,毫无保留地分享给大家。 4116

C++是如何实现多态的

C++是如何实现多态的 结论:C++通过虚函数来实现多态的,根本原因是派生类和基类的虚函数表的不同。 构成多态的必要条件有如下3点: 存在继承关系 基类存在虚函数,且派生类有同原型的函数遮蔽它 存在基类类型的指针指向派生类对象,且该指针调用了存在覆盖关系的虚函数 如下图,就是一个简单的多态的例子:(实验环境:vs2019) 大猪眉头一皱,觉得事情并不简单。 针对上述实验结果,有个疑点: 基...

qq_18138105的博客 2450

【C++】C++ 多态的底层实现

C++通过虚函数和虚表实现了强大的多态性机制,允许程序在运行时动态地决定调用哪个函数。这种机制虽然引入了一定的内存和性能开销,但在面向对象编程中提供了极大的灵活性。理解其底层实现对于编写高效、健壮的C++代码具有重要意义。

2403_86785171的博客 1758

【C++】多态的定义以及实现 || 抽象类 || 多态原理

多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。比如Student继承了 Person。Person对象买票全价, Student对象买票半价。那么在继承中要构成多态还有两个条件:1. 必须通过基类的指针或者引用调用虚函数2. 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写public:cout

强哥的微博 1565

C++多态实现原理

多态含义为一个事物有多种形态。在C ++程序设计中,多态性是指具有不同功能的函数可以用同一个函数名,这样就可以用一个函数名调用不同内容的函数。重载多态和强制多态是指特定多态, 重载多态和强制多态称为特殊多态性,用来刻画语义上无关联的类型间的关系;参数多态和包含多态是指通用多态,类型参数化多态和包含多态称为一般多态性,用来系统地刻画语义上相关的一组类型。在基类的函数前加上virtual关键字,在派生类中重写该函数,运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是子类,就调用子类的函数;

wo_ai_luo_的博客 2791

[C++]认识多态和多态的实现

关于多态的使用操作和实现原理的详细讲解

weixin_52345097的博客 505

什么是 C++ 多态, C++ 多态的实现原理是什么

在 C++ 程序设计中,多态性是指具有不同功能的函数可以用同一个函数名,这样就可以用一个函数名调用不同内容的函数。在面向对象方法中,一般是这样表述多态性的:向不同的对象发送同一个消息,不同的对象在接收时会产生不同的行为(即方法);也就是说,每个对象可以用自己的方式去响应共同的消息所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。换言之,可以用同样的接口访问功能不同的函数,从而实现“一个接口,多种方法”。在C++中主要分为静态多态和动态多态两种,在程序运行前就完成联编的称为静态多态,主要通

weixin_45032957的博客 5158

c++多态,为何只能通过指针或引用实现

一览本文目的内存切割尾语 本文目的     在c++的多态中,如果一个基类的虚函数被派生类重写,那么把基类的指针指向派生类,就能够通过基类调用被派生类重写的这个虚函数。(对于这点有疑问的,可以看我之前写的C++多态,虚函数,虚函数表,gcc下的单继承,多继承,虚继承的内存布局)。那么如果不用指针或引用会如何? class Animal{ public: ...

Lupin 9136

CPP静态“多态”的几种实现方案

c++静态多态的几种实现方式

Mr.Sugarcane 625

C语言模式实现C++继承和多态

这个问题主要考察的是C和C++的区别,以及C++中继承和多态的概念。C和C++的区别C语言是面向过程的语言,而C++是面向对象的过程。什么是面向对象和面向过程? 面向过程就是分析解决问题的步骤,然后用函数把这些步骤一步一步的进行实现,在使用的时候进行一一调用就行了,注重的是对于过程的分析。面向对象则是把构成问题的事进行分成各个对象,建立对象的目的也不仅仅是完成这一个个步骤,而是描述各个问题在解决的过

菜鸟成长记 1万+

c++ 多态的实现及原理

1. 什么是多态? 多态就是多种形态,C++的多态分为静态多态与动态多态。静态多态就是重载,因为在编译期决议确定,所以称为静态多态。动态多态就是通过继承重写基类的虚函数实现的多态,因为是在运行时决议确定,所以称为动态多态。运行时在虚函数表中寻找调用函数的地址。 c++的多态性用一句话概括:在基类的函数前加上virtual关键字,在派生类中重写该函数,运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类,就调用派生类的函数;如果对象类型是基类,就调用基类的函数...

m0_37715028的博客 3098
上一篇: C++多态的实现原理
下一篇: C++当多次调用同一实参的模板,到底编译器实列化几次份代码的问题
SprintfWater
博客等级 码龄15年 242粉丝 139原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值