精华内容
下载资源
问答
  • 多态性也分静态多态性动态多态性两种。静态多态性是指定义在一个类或一个函数中的同名函数,它们根据参数表(类型以及个数)区别语义,并通过静态联编实现,例如,在一个类中定义的不同参数的构造函数。动态多态

    多态性:

             多态性就是多种表现形式,具体来说,可以用"一个对外接口,多个内在实现方法"表示。举一个例子,计算机中的堆栈可以存储各种格式的数据,包括整型,浮点或字符。不管存储的是何种数据,堆栈的算法实现是一样的。针对不同的数据类型,编程人员不必手工选择,只需使用统一接口名,系统可自动选择。

    多态性也分静态多态性和动态多态性两种。静态多态性是指定义在一个类或一个函数中的同名函数,它们根据参数表(类型以及个数)区别语义,并通过静态联编实现,例如,在一个类中定义的不同参数的构造函数。动态多态性是指定义在一个类层次的不同类中的重载函数,它们一般具有相同的函数,因此要根据指针指向的对象所在类来区别语义,它通过动态联编实现。

     

    纯虚函数和虚函数:

    image

    纯虚函数用来规范派生类的行为,即接口,也就是说让派生类和基类有相同的接口

    image

    虚函数实现多态性

    image

    image

    不能声明抽象类的对象,但是能声明指向抽象类的指针。

    抽象类:

    含有纯虚函数的类叫做抽象类。

    展开全文
  • C++多态性

    万次阅读 2016-02-16 21:26:25
    1.2从系统实现的角度看,多态性分两类:静态多态性动态多态性。 静态多态性是通过函数重载(运算符重载也是函数重载)来实现的。它又称为编译时多态。 动态多样性是在程序运行过程中才动态确定操作所针对的对象。...

    C++多态

    1.1多态性(polymorphism)是面向对象程序设计的一个重要特征。
    1.2从系统实现的角度看,多态性分两类:静态多态性与动态多态性。
    静态多态性是通过函数重载(运算符重载也是函数重载)来实现的。它又称为编译时多态。
    动态多样性是在程序运行过程中才动态确定操作所针对的对象。它又称为运行时多态,动态多态性是通过虚函数来实现的。
    1.3一段代码:
    #include <iostream>
    
    
    using namespace std;
    
    
    class Point
    {
    public:
        Point(float a=0,float b=0);
        void setPoint(float a,float b);
        float getX() const {return x;}
        float getY() const {return y;}
        friend ostream& operator << (ostream& output,Point& p);
    protected:
        float x,y;
    };
    
    
    Point::Point(float a, float b)
    {
        x=a;
        y=b;
    }
    
    
    void Point::setPoint(float a, float b)
    {
        x=a;
        y=b;
    }
    
    
    ostream& operator << (ostream& output,Point& p)
    {
        output << "[" << p.getX() << "," << p.getY() << "]" << endl;
        return output;
    }
    
    
    class Circle:public Point
    {
    public:
        Circle(float a,float b,float r):Point(a,b),radius(r){}
        void setRadius(float r);
        float getRadius() const {return radius;}
        float area() const;
        friend ostream& operator << (ostream& output,Circle &c);
    protected:
        float radius;
    };
    
    
    void Circle::setRadius(float r)
    {
        radius=r;
    }
    
    
    float Circle::area() const
    {
        return 3.14159*radius*radius;
    }
    
    
    ostream& operator << (ostream& output,Circle &c)
    {
        output << "Center [" << c.x << "," << c.y << "] radius=" << c.radius
               << " area=" << c.area() << endl;
        return output;
    }
    
    
    class Cylinder:public Circle
    {
    public:
        Cylinder(float a,float b,float r,float h):Circle(a,b,r),height(h){}
        void setHeight(float h){height=h;}
        float getHeight() const{return height;}
        float area() const;
        float volume() const;
        friend ostream& operator << (ostream& output,Cylinder& cy);
    protected:
        float height;
    };
    
    
    float Cylinder::area() const
    {
        return 2*Circle::area()+2*3.14159*radius*height;
    }
    
    
    float Cylinder::volume() const
    {
        return Circle::area()*height;
    }
    
    
    ostream& operator << (ostream& output,Cylinder& cy)
    {
        output << "Center [" << cy.getX() << "," << cy.getY() << "] r="
               << cy.radius << "\narea=" << cy.area() << " volume=" << cy.volume()
               << endl;
        return output;
    }
    
    
    
    
    
    
    int main()
    {
        Cylinder cy(1,2,3,4);
        cout <<"Cylinder\n" << "Center [" << cy.getX() << "," << cy.getY() << "] r="
               << cy.getRadius() << "\narea=" << cy.area() << " volume=" << cy.volume()
               << endl;
        cy.setHeight(1);
        cy.setPoint(2,3);
        cy.setRadius(4);
        cout << "Cylinder\n" << cy << endl;
        Point &p=cy;
        cout << "Point\n" << p;
        Circle &c=cy;
        cout << "Circle\n" << c;
        return 0;
    }
    
    
    
    1.4在本例中存在静态多态性,这是由运算符重载引起的,可以看到,在编译时编译系统即可以判定应调用哪个运算符函数。
    展开全文
  • 多态性(一)——静态多态性

    千次阅读 2015-03-04 12:18:55
    多态性(polymorphism)是面向对象程序设计的一个重要特征。在面向对象方法中,一般是这样表述多态性的:... 从系统实现的角度来看,多态性分两类:静态多态性动态多态性。 静态多态性是通过函数重载实现的。要求在

      多态性(polymorphism)是面向对象程序设计的一个重要特征。在面向对象方法中,一般是这样表述多态性的:向不同的对象发送同一个消息,不同的对象在接收时会产生不同的行为。在C++中,多态性表现形式之一是:具有不同功能的函数可以用同一个函数名,这样就可以实现用一个函数名调用不同内容的函数。

      从系统实现的角度来看,多态性分两类:静态多态性动态多态性。 静态多态性是通过函数重载实现的。要求在程序编译时就知道调用函数的全部信息,因此,在程序编译时系统就能决定要调用的是哪个函数。动态多样性的特点是:不在编译时确定调用的是哪个函数,而是在程序运行过程中才动态地确定操作针对的对象。动态多态性是通过虚函数(virtual function)实现的。 

      本文先来介绍一下静态多态性,下面用一个例子简单介绍一下函数重载和函数覆盖。


    (程序会比较长,对于一个比较长的程序,应当分成若干步骤进行分析。)

    首先定义一个Point类作为基类:

    #ifndef POINT
    #define POINT
    #include
    using namespace std;
    
    class Point
    {public:
    Point(float x=0.0,float y=0.0);
    void setPoint(float,float);
    float getX()const{return x;};
    float getY()const{return y;};
    friend ostream & operator<<(ostream &output,const Point &p)//友元重载运算符<<
    {output<<"["<

    然后是定义Circle类,属于Point的公有派生类:

    #ifndef CIRCLE
    #define CIRCLE
    #include
    #include"Point.h"
    using namespace std;
    
    class Circle:public Point
    {public:
    Circle(float x=0.0,float y=0.0,float r=0.0);
    void setRadius(float);
    float getRadius()const;
    float area()const;
    friend ostream & operator<<(ostream &output,const Circle &c)//友元重载运算符<<
    {output<<"Center=["<

    然后是定义Cylinder类,属于Circle类的公有派生类:

    #ifndef CYLINDER
    #define CYLINDER
    #include
    #include"Circle.h"
    #include"Point.h"
    using namespace std;
    
    class Cylinder:public Circle
    {public:
    Cylinder(float x=0.0,float y=0.0,float r=0.0,float h=0.0);
    void setHeight(float);
    float getHeight() const;
    float area() const;
    float volume() const;
    friend ostream& operator<<(ostream &output,const Cylinder& cy)
    {output<<"Center=["<

    最后是main函数,测试这三个类:

    #include
    #include"Point.h"
    #include"Circle.h"
    #include"Cylinder.h"
    using namespace std;
    
    int main()
    {
        
    cout<<"测试Point类:"<


    测试结果如下图:



      下面我们来分析以上三个类:

      可以看出,在Point类中,我们声明了一次运算符“<<”重载函数,在Circle类中,我们又声明了一次运算符“<<”重载函数,两次重载的运算符“<<”内容是不一样的,在编译时编译系统会根据输出项的类型确定调用哪一个运算符重载函数,这属于静态多态性。

    (一)请注意main函数中的:Point &pRef=c;(例一处)

      该处定义了Point类的引用pRef,并用派生类Circle对象c对其初始化。Circle是Point的公用派生类,因此,对象c包括了公用基类部分和公用派生类新增部分,因为引用pRef被定义为Point类,所以,pRdf不能认为是代表了c,它只是代表了c中公用基类的部分。引用pRef得到了c的起始地址,与c中公用基类部分共享了同一段存储单元。所以用“cout<<pRef”输出时,调用的不是Circle中声明的运算符重载函数,而是在Point中声明的运算符重载函数,输出的是“点”的信息,而不是“圆“的信息。


    (二)请注意Cylinder类定义中的area函数(例二处)
      该处的area函数与Circle类中定义的area函数同名,在main函数调用cyl.area()(例三处)时,调用的是Cylinder类的area函数。这里两个类的area函数并不是重载函数,因为它们不仅函数名相同,而且函数类型和参数个数都相同,这样的两个函数不在同一个类中,而是分别在基类和派生类中,属于同名覆盖。


    (三)注意main函数中的:Point &ppRef=cyl;(例四处)和Circle &cRef=cyl;(例五处)

      与例一处相同,ppRef为cyl中属于Point类的那部分,cRef为cyl中属于Circle类的那部分。所以输出的分别是“点”和“圆”,而不是“圆柱”。

      

      在本文的程序中,有三个运算符函数时重载(不是同名覆盖),而在编译时,编译系统即可判定应该调用哪个重载运算符函数,这体现了静态多态性。



    参考资料:《C++程序设计与分析(第二版)》.谭浩强.清华大学出版社.2011.8.pag392-398

    展开全文
  • 多态性

    千次阅读 2013-09-09 14:24:53
    面向对象程序设计中的多态性多态性(polymorphism)是面向对象编程的基本特征之... 从系统实现角度来看,多态性分为两类:静态多态性动态多态性。  静态多态性:在程序编译时系统就能决定调用哪个函数,因此静态函

    面向对象程序设计中的多态性:

    多态性(polymorphism)是面向对象编程的基本特征之一。在c++中指具有不同功能的函数可以用同一个函数名,即可以用同一个函数名调用不同内容的函数。向不同对象发送同一个消息,不同的对象在接收同一消息时会产生不同的行为(方法)。
      从系统实现角度来看,多态性分为两类:静态多态性动态多态性
      静态多态性:在程序编译时系统就能决定调用哪个函数,因此静态函数又称编译时的多态性(实质上是通过函数的重载实现)。例如:函数的重载和运算符重载实现.
      动态多态性:运行过程中才动态地确定操作指针所指的对象,主要通过虚函数和重写来实现。

    在C++中,多态性通过虚函数(virtual function)来实现。虚函数在基类中定义,目的是不确定其派生类的具体行为。

    例:定义一个基类:class animal//动物。它的函数为breathe()//呼吸。
    再定义一个类class Fish//鱼 。它的函数也为breathe()
    再定义一个类class Sheep //羊。它的函数也为breathe()
    为了简化代码,将Fish,Sheep定义成基类Animal的派生类。
    然而Fish与Sheep的breathe不一样,一个是在水中通过水来呼吸,一个是直接呼吸空气。所以基类不能确定该如何定义breathe,所以在基类中只定义了一个virtual breathe,它是一个空的虚函数。具体的函数在子类中分别定义。程序一般运行时,先找到类,如果它有基类,再找它的基类,最后运行的是基类中的函数,这时,它在基类中找到的是virtual标识的函数,它就会再回到子类中找同名函数。派生类也叫子类,基类也叫父类。这就是虚函数的产生以及类的多态性(breathe)的体现。
    这里的多态性是指类的多态性。

    函数的多态性是指一个函数被定义成多个不同参数的函数,它们一般被存在头文件中,当你调用这个函数时,针对不同的参数,就会调用不同的同名函数。例:Rect()//矩形。它的参数可以是两个坐标点(point,point),也可能是四个坐标(x1,y1,x2,y2),这叫函数的多态性与函数的重载。

    展开全文
  • C++ 多态性 (polymorphism)

    千次阅读 2021-05-14 15:40:23
    C++ 多态性 (polymorphism). 多态性是什么以及如何帮我们实现一个易于扩展的程序.
  • 多态性定义

    千次阅读 2010-09-07 10:35:00
     多态性也分静态多态性动态多态性两种。静态多态性是指定义在一个类或一个函数钟的同名函数,它们根据参数表(类型以及个数)区别语义,并通过静态联编实现,例如,在一个类中定义的不同参数的构造函数。...
  • 类的多态性的概念

    千次阅读 2013-08-27 16:32:10
    多态性(polymorphism)是面向对象程序设计的一个重要特征。利用多态性可以设计和实现一个易于扩展的系统。 在C++程序设计中,多态性是指具有不同功能的函数可以用同一个函数名,这样就可以用一个函数名调用不同内容...
  • 从系统实现的角度,多态性分为两类:静态多态性动态多态性。...动态多态性是在程序运行过程中才动态地确定操作所针对的对象。它又称为运行时的多态性动态多态性是通过虚函数(virtual function)实现的。
  • C++多态性的理解

    千次阅读 2017-04-15 20:30:05
    (1)抽象类是一种特殊的类,它为一族类提供统一的操作界面,通过它为一个类族建立一个公共的接口,使类能够更加有效的发挥多态性。 (2)建立抽象类,就是为了通过它多态地使用其中的成员函数。 (3)抽象类...
  • 习题五 多态性和虚函数

    千次阅读 2018-06-27 21:54:00
    (2)C++支持两种多态性,静态联编所支持的多态性被称为 编译时的多态性 、动态联编所支持的多态性被称为 运行时的多态性 。(3)重载函数在编译时表现出多态性,就是 静态 联编;而虚函数则在运行时表现出多态...
  • C++多态性,虚函数,重载,抽象类

    千次阅读 2016-07-21 14:55:17
    1,C++多态性,虚函数,重载,比较有意思,,,,,, 在面向对象的程序中,当不同的对象接受到相同的消息产生不同的动作,这种性质称为多态性
  • java 类的封装性、继承性、多态性

    千次阅读 2018-07-31 20:56:48
    多态性(Java允许单继承,派生类与基类间有IS-A的关系(即“猫”is a “动物”)。这样做虽然保证了继承关系的简单明了,但是势必在功能上有很大的限制,多态性的引入用来弥补这点的不足) 记录下看了一些博客...
  • 虚函数和多态性

    千次阅读 2013-03-24 15:16:42
    多态性是指通过(基类)指针或(基类)引用调用函数,这种调用是动态解析的,即在编译期间确定调用哪个函数。 因为派生类对象包含一个完整的基类对象,换句话说,每个派生类对象也是一个基类对象。因此,可以用基类...
  • SNP/单核苷酸多态性分析

    千次阅读 2018-10-19 11:02:00
    SNP/单核苷酸多态性分析 SNP(Single Nucleotide Polymorphism),即单核苷酸多态性,是由于单个核苷酸改变而导致的核酸序列多态。一般来说,一个SNP位点只有两种等位基因,因此又叫双等位基因。SNP在人类基因组中...
  • 第十二章、多态性与虚函数     1,在C++中,多态性是指具有不同功能的函数可以用同一个函数名,这样就可以用一个函数名调用不同内容...动态多态性是在程序运行过程中才动态地确定操作所针对的对象;它是通过虚函数
  • 多态性与虚函数——C/C++学习笔记

    千次阅读 2015-07-16 20:58:39
    多态性(polymorphism) 即:向不同对象发送同一个消息,不同的对象在接收时候会...C++多态性分为:静态多态性 和 动态多态性 静态多态性:通过函数重载或者运算符重载实现,在编译阶段即知道函数的全
  • 多态性动态联编的分析

    千次阅读 2006-05-15 16:17:00
    多态性是C++最主要的特征,多态性的实现得益于C++中的动态联编技术。文章通过对动态联编的关键技术虚拟函数表进行深入的剖析,解析的动态联编的过程极其技术要领。 关键字 多态性 动态联编 VTABLE 虚函数 文章...
  • 面向对象-多态性

    千次阅读 2007-03-21 22:28:00
    面向对象的软件开发语言具有三个重要的特点分别为封装性、继承性、多态性。封装性即意味着对象封装其内部的数据,使其对外不可见,以保证数据的安全性。继承性是代码复用的一个很好的解决方案,但是继承关系是编译器...
  • Java面向对象编程——多态性的实现

    千次阅读 2017-12-18 20:41:13
    Java中多态性的实现 一、使用父类类型的引用指向子类的对象 二、该引用只能调用父类中定义的方法和变量; 三、如果子类中重写了父类中的一个方法,那么在调用这个方法的 时候,将会调用子类中的这个方法;(动态...
  • java多态性学习&子类给父类赋值

    千次阅读 2014-02-22 14:39:44
    ava的多态性 面向对象编程有三个特征,即封装、继承和多态。... 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来的非
  • 多态性与虚函数

    千次阅读 2011-08-22 15:18:44
    多态性与虚函数  面向对象理论中的3个术语:对象、方法和消息。对象(object):不言而喻,它是构成系统的基本单位,有属性和行为两个要素,在C++中,每个对象都是由数据和函数这两部分组成的,数据即是对象的...
  • Java多态性详解——父类引用子类对象

    万次阅读 多人点赞 2013-05-21 21:07:02
    面向对象编程有三个特征,即封装... 方法的重写、重载与动态连接构成多态性。Java之所以引入多态的概念,原因之一是它在类的继承问题上和C++不同,后者允许多继承,这确实给其带来的非常强大的功能,但是复杂的继承关
  • 第十八讲:C++多态性与虚函数

    千次阅读 2010-12-19 09:51:00
    第十八讲:C++多态性与虚函数 本讲基本要求  * 掌握:多态性的概念;虚函数的定义及应用。  * 理解:对象与类函数的静态关联与动态关联。  重点、难点: :多态性的概念;虚函数的定义...
  • 实验六 多态性与虚函数

    千次阅读 2018-06-07 11:14:09
    一、实验目的和要求 了解静态联编的动态联编的概念。掌握动态联编的条件。二、实验内容1.分析并调试下列程序。
  • 实验 六 多态性与虚函数

    千次阅读 2018-05-20 15:30:06
    一、实验目的和要求 了解静态联编的动态联编的概念。掌握动态联编的条件。二、实验内容1.分析并调试下列程序。//sy6_1.cpp #include&lt;iostream&gt; using namespace std; class Base { public: virtual...
  • C++中多态性和重载

    千次阅读 2016-03-10 19:37:22
    1.封装:保证对象自身数据的完整、安全 2.继承:建立类之间的关系,实现代码复用、方便系统的扩展 3.多态:相同的方法调用可实现不同的实现方式。多态是指两个或个属于不同类的对象,对于同一个消息...
  •  上一篇讲述了C++中的多态性,由于多态性是面向对象编程中常用的特性,所以JAVA作为面向对象的主流语言自然也有多态性,它的多态性其实和C++的概念差不多,只是实现形式和表现形式不一样。在C++中可能还会提到多态...
  • 面向对象JAVA多态性

    千次阅读 2011-12-29 12:21:40
    在Java中,多态性是依靠动态绑定实现的,即Java 虚拟机 在运行时确定要调用哪一个同名方法。 多态的应用 由于多态性,一个父类的引用变量可以指向不同的子类对象,并且在运行时根据父类引用变量所指向...
  • 多态(Polymorphism),在面向对象语言中指的是同一个接口可以有多种不同的实现方式,OC中的多态则是不同对象对同一消息的不同响应方式,子类通过重写父类的方法来改变同一消息的实现,体现多态性。另外我们知道C++...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,427
精华内容 28,970
关键字:

动态多态性只针对