精华内容
下载资源
问答
  • 动态多态
    2022-05-03 10:27:26

    多态:静态多态和动态多态

    多态的实现主要分为静态多态动态多态,静态多态主要是重载和模板,在编译的时候就已经确定;动态多态是用虚函数机制实现的,在运行期间动态绑定。
    举个例子:一个父类类型的指针指向一个子类对象时候,使用父类的指针去调用子类中重写了的父类中的虚函数的时候,会调用子类重写过后的函数,在父类中声明为加了virtual关键字的函数,在子类中重写时候不需要加virtual也是虚函数。

    虚函数的实现

    虚函数表 指向虚函数表的指针

    在有虚函数的类中,类的最开始部分是一个虚函数表的指针,这个指针指向一个虚函数表,表中放了虚函数的地址,实际的虚函数在代码段(.text)中。当子类继承了父类的时候也会继承其虚函数表,当子类重写父类中虚函数时候,会将其继承到的虚函数表中的地址替换为重新写的函数地址。使用了虚函数,会增加访问内存开销,降低效率。

    更多相关内容
  • 动态多态的基础知识: 首先百度自己去弄懂什么是静态多态?什么是动态多态 易语言的类方法全部是强制成虚函数的 具体参考易语言目录下的例子 e\samples\基本例程\面向对象编程.e 易语言面对对象编程 类的创建与使用 ...
  • Java动态多态原理

    2021-02-27 13:02:57
    多态分为几种:多态分为静态多态、动态多态什么是静态多态静态多态性指的是程序在编译时,系统就能决定调用哪个函数,一般指的是重载,是在一个类中的行为。重载,就是在类中创建多个方法,它们具有相同的名字,但...

    很多书本说到多态,概念就把人看晕了,本人从实际使用角度,来介绍多态,希望对大家有用。

    什么是多态:

    多态简单来说,就是调用同一个函数名字,会出现不同的运行结果。

    多态分为几种:

    多态分为静态多态、动态多态

    什么是静态多态

    静态多态性指的是程序在编译时,系统就能决定调用哪个函数,一般指的是重载,是在一个类中的行为。

    重载,就是在类中创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性

    例如:

    public class Dog {

    void bark()//bark()方法是重载方法

    {

    System.out.println(\'no barking!\');

    this.bark(\'female\', 3.4);

    }

    void bark(String m,double l)//注意:重载的方法的返回值都是一样的,

    {

    System.out.println(\'a barking dog!\');

    this.bark(5, \'China\');

    }

    void bark(int a,String n)//不能以返回值区分重载方法,而只能以“参数类型”和“类名”来区分

    {

    System.out.println(\'a howling dog\');

    }

    }

    什么是动态多态

    动态多态性是指方法的重写,是在有继承关系的两个或两个以上的类中的行为。一般子类通过实现父类函数,允许基类的指针或引用指向派生类的对象,而在具体访问时实现方法的动态绑定。

    以java为例:

    public class Fruit {……

    public void show_name(int num){

    System.out.println('Fruit: '+mum);

    }

    }

    public class Apple extends Fruit{

    @Override

    public void show_name(int num){

    System.out.println('Apple');

    }

    }

    如何实现动态多态

    方法表与方法调用

    方法表是动态调用的核心,也是 Java 实现动态调用的主要方式。它被存储于方法区中的类型信息,包含有该类型所定义的所有方法及指向这些方法代码的指针,注意这些具体的方法代码可能是被覆写的方法,也可能是继承自基类的方法。

    如有类定义 Person, Girl, Boy,

    清单 1

    class Person {

    public String toString(){

    return 'I'm a person.';

    }

    public void eat(){}

    public void speak(){}

    }

    class Boy extends Person{

    public String toString(){

    return 'I'm a boy';

    }

    public void speak(){}

    public void fight(){}

    }

    class Girl extends Person{

    public String toString(){

    return 'I'm a girl';

    }

    public void speak(){}

    public void sing(){}

    }

    当这三个类被载入到 Java 虚拟机之后,方法区中就包含了各自的类的信息。Girl 和 Boy 在方法区中的方法表可表示如下:

    图 3.Boy 和 Girl 的方法表

    84264329_1

    可以看到,Girl 和 Boy 的方法表包含继承自 Object 的方法,继承自直接父类 Person 的方法及各自新定义的方法。注意方法表条目指向的具体的方法地址,如 Girl 的继承自 Object 的方法中,只有 toString() 指向自己的实现(Girl 的方法代码),其余皆指向 Object 的方法代码;其继承自于 Person 的方法 eat() 和 speak() 分别指向 Person 的方法实现和本身的实现。

    Person 或 Object 的任意一个方法,在它们的方法表和其子类 Girl 和 Boy 的方法表中的位置 (index) 是一样的。这样 JVM 在调用实例方法其实只需要指定调用方法表中的第几个方法即可。

    如调用如下:

    清单 2

    class Party{

    void happyHour(){

    Person girl = new Girl();

    girl.speak();

    }

    }

    当编译 Party 类的时候,生成 girl.speak()的方法调用假设为:

    Invokevirtual #12

    设该调用代码对应着 girl.speak(); #12 是 Party 类的常量池的索引。JVM 执行该调用指令的过程如下所示:

    图 4. 解析调用过程

    84264329_2

    JVM 首先查看 Party 的常量池索引为 12 的条目(应为 CONSTANT_Methodref_info 类型,可视为方法调用的符号引用),进一步查看常量池(CONSTANT_Class_info,CONSTANT_NameAndType_info ,CONSTANT_Utf8_info)可得出要调用的方法是 Person 的 speak 方法(注意引用 girl 是其基类 Person 类型),查看 Person 的方法表,得出 speak 方法在该方法表中的偏移量 15(offset),这就是该方法调用的直接引用。

    当解析出方法调用的直接引用后(方法表偏移量 15),JVM 执行真正的方法调用:根据实例方法调用的参数 this 得到具体的对象(即 girl 所指向的位于堆中的对象),据此得到该对象对应的方法表 (Girl 的方法表 ),进而调用方法表中的某个偏移量所指向的方法(Girl 的 speak() 方法的实现)。

    接口调用

    因为 Java 类是可以同时实现多个接口的,而当用接口引用调用某个方法的时候,情况就有所不同了。Java 允许一个类实现多个接口,从某种意义上来说相当于多继承,这样同样的方法在基类和派生类的方法表的位置就可能不一样了。

    清单 3

    interface IDance{

    void dance();

    }

    class Person {

    public String toString(){

    return 'I'm a person.';

    }

    public void eat(){}

    public void speak(){}

    }

    class Dancer extends Person

    implements IDance {

    public String toString(){

    return 'I'm a dancer.';

    }

    public void dance(){}

    }

    class Snake implements IDance{

    public String toString(){

    return 'A snake.';

    }

    public void dance(){

    //snake dance

    }

    }

    图 5.Dancer 的方法表

    84264329_3

    可以看到,由于接口的介入,继承自于接口 IDance 的方法 dance()在类 Dancer 和 Snake 的方法表中的位置已经不一样了,显然我们无法通过给出方法表的偏移量来正确调用 Dancer 和 Snake 的这个方法。这也是 Java 中调用接口方法有其专有的调用指令(invokeinterface)的原因。

    Java 对于接口方法的调用是采用搜索方法表的方式,对如下的方法调用

    invokeinterface #13

    JVM 首先查看常量池,确定方法调用的符号引用(名称、返回值等等),然后利用 this 指向的实例得到该实例的方法表,进而搜索方法表来找到合适的方法地址。

    因为每次接口调用都要搜索方法表,所以从效率上来说,接口方法的调用总是慢于类方法的调用的。

    展开全文
  • C++中的多态分为两种:静态多态与动态多态 一、静态多态:也成为编译时的多态;在编译时期就已经确定要执行了的函数地址了;主要有函数重载和函数模板(这里只写函数重载) (1)函数重载 因为C++中确定执行的函数...

    多态:即一个接口多种实现方式;C++中的多态分为两种:静态多态与动态多态

    一、静态多态:也成为编译时的多态;在编译时期就已经确定要执行了的函数地址了;主要有函数重载和函数模板(这里只写函数重载)


    (1)重写基类函数(方法)

    C++中当我们一个类继承于一个另一个类时,我们在派生类中不想使用基类中的函数,想重新写一个同名函数,这是被允许的;因此我们的基类与派生类可以有同名的函数;例如我们现在有一个类中已经有了一个函数名为show无参的函数,我们在派生类中再写一个名为show函数,这叫函数重载也称为覆盖和重写;


    测试代码:

    #include <iostream>
    
    using namespace std;
    
    class AA
    {
    public:
    	void show(){
    		cout << "我是show1" << endl;
    	}	
    };
    
    class BB :public AA
    {
    public:
    	void show(){
    		cout << "我是show2" << endl;
    	}	
    };
    
    int main()
    {
    	BB a;
    	a.show();	//输出show2
        //a.show(); //此时会报错:没有匹配的函数,因为已经被重写了基类中的函数
    	//a.AA::show();//正常输出AA类中的数据
    
    	return 0;
    }
    
    

    运行结果:
    静态多态

    因为此时派生类中重写了父类中的同名函数,因此在BB类中看到的show的函数是派生类中的重写后的show函数;其实AA类中的show函数还是存在的,并不是说重写了函数后,它就不存在了因此我们还是可以通过指定类中=名去调用AA类中的函数



    二动态多态:即动态绑定,在运行时才去确定对象类型和正确选择需要调用的函数,一般用于解决基类指针或引用派生类对象调用类中重写的方法(函数)时出现的问题

    测试代码:

    #include <iostream>
    
    using namespace std;
    
    class AA
    {
    public:
    	AA(){
                    cout << "AA()的构造函数"<<endl;
        }
    
        ~AA(){
                     cout << "AA()的析构函数"<<endl;
        }
    
    	void show(){
    		cout << "我是show1" << endl;
    	}	
    };
    
    class BB :public AA
    {
    public:
    	BB(){
    	               cout << "BB()的构造函数"<<endl; 
    	}
    	   
          ~BB(){
                  cout << "BB()的析构函数"<<endl; 
          }
    
    	void show(){
    		cout << "我是show2" << endl;
    	}	
    };
    
    int main()
    {
    	//使用指针时在析构时只会调用基类中地析构函数
    	//AA * d = new BB();
        //d->show();	
    	
    	BB a;
    	AA &b = a;
    	b.show();
    	
    	//delete d; //使用指针时用于释放内存
    	return 0;
    }
    
    

    运行结果:
    (1)引用
    在这里插入图片描述
    (2)指针:
    在这里插入图片描述

    很明显该程序执行的结果并没有按照AA类型的指针指向的真正的内容去执行对应的代码,而我们是想要编译器能够正确地知道AA &b(或指针)所指向地内容是什么类型的而不是根据当前指针或引用的类型去判断调用什么函数,此时我们实现这种动态多态就需要通过使用关键字virtual来实现;

    (1)virtual 修饰的函数称为虚函数,其是通过使用virtual关键字后产生一个虚表(虚函数表),然后每一个对象会创建一个虚表,虚表存放当前对象拥有的虚函数
    (2)当虚函数被创建后就会被放入虚表,当派生类重写虚函数后,创建派生类对象时会把虚表内的对应函数地址换成派生类中重写的函数地址

    虚表

    注意:
    (1)每次执行虚函数都会去重新去替换掉原来虚表的位置
    (2)当使用虚函数后原来函数的存放位置会分配一个指针用于指向虚表中函数的地址
    (3)一个对象可以拥有多个虚函数,但只能有一个虚表

    测试代码:

    #include <iostream>
    
    using namespace std;
    
    class AA
    {
    public:
            AA(){
                    cout << "AA()的构造函数"<<endl;
        }   
    
        ~AA(){
                     cout << "AA()的析构函数"<<endl;
        }   
    
            virtual void show(){
                    cout << "我是show1" << endl;
            }    
    };
    
    class BB :public AA
    {
    public:
            BB(){
                           cout << "BB()的构造函数"<<endl;
            }
    
          ~BB(){
                  cout << "BB()的析构函数"<<endl;
          }
    
            void show(){
                    cout << "我是show2" << endl;
            }
    };
    
    int main()
    {
    
            BB a;
            AA &b = a;
            b.show();
    
            return 0;
    }
    
    

    运行结果:

    在这里插入图片描述
    关于虚表地址:
    在这里插入图片描述
    此时就会根据对象去正确地选择函数调用了


    《纯粹个人理解,有错的地方麻烦提醒一下;非常感谢》

    展开全文
  • 动态多态的好处 案例描述: 分别利用普通写法和多态技术:设计实现两个操作数进行运算的计算器类 多态的有点: 代码组织结构清晰 可读性强 利于前期和后期的扩展以及维护 先来看一下普通实现写法: #...

    动态多态的好处

    案例描述:

    分别利用普通写法和多态技术:设计实现两个操作数进行运算的计算器类

    多态的有点:

    • 代码组织结构清晰
    • 可读性强
    • 利于前期和后期的扩展以及维护

    先来看一下普通实现写法: 

    #include<iostream>
    using namespace std;
    
    // 多态带来的好处:
    // 分别利用普通写法和多态技术实现计算器。
    class Calculator
    {
    public:
    
    	int getResult(string oper)
    	{
    		if (oper=="+")
    		{
    			return m_Num1 + m_Num2;
    		}
    		else if (oper=="-")
    		{
    			return m_Num1 - m_Num2;
    		}
    		else if (oper=="*")
    		{
    			return m_Num1 * m_Num2;
    		}
    		// else
    		// 如果想扩展新的功能,比如:平方,立方,开方等,需要修改源码。
    		// 在真实开发中 提倡 开闭 原则。
    		// 开闭原则:对扩展进行开放,对修改进行关闭。
    		// 因为修改的话:要整体大段代码查询,如果要扩展,只要继承重载就可以。
    		// 如果用多态,就方便多了。
    	}
    
    	int m_Num1;
    	int m_Num2;
    };
    
    void test01()
    {
    	Calculator cal;
    	cal.m_Num1 = 10;
    	cal.m_Num2 = 20;
    
    	cout << cal.m_Num1 << " + " << cal.m_Num2 << " = " << cal.getResult("+") << endl;
    	cout << cal.m_Num1 << " - " << cal.m_Num2 << " = " << cal.getResult("-") << endl;
    	cout << cal.m_Num1 << " * " << cal.m_Num2 << " = " << cal.getResult("*") << endl;
    
    }
    
    int main()
    {
    
    	test01();
    	system("pause");
    	return 0;
    }

    在计算器类Calculator中getResult方法将类中两个成员相加。方法中有个string类型参数,输入不同的string符号,来实现多态控制。

    但是这样有个问题:如果后续需要增加其他运算,比如平方,就需要修改源码,并且,修改完之后,要检查整体代码有没有问题。如此做法有违编程的开闭原则

    开闭原则:对扩展进行开放,对修改进行关闭。

    《C#学习笔记(二十二)抽象类与开闭原则:抽象类和接口怎么来的?》一文中:我们提到:

     我们应该封装一些固定,不变的,稳定的、确定的成员;把不确定的,有可能改变的成员抽象为抽象成员、抽象类,留给子类去实现。

    抽象类和开闭原则天生就是一对。




    利用多态实现计算器

    先声明一个抽象类AbstractCalculator类中什么功能都不写。声明两个成员属性待用。把getResult函数抽象出来,写为虚函数,因为不知道后面具体如何实现,所以函数内部,只要写一个return 0即可。类似于C#中的接口类或者抽象类。

    class AbstractCalculator
    {
    public:
    	virtual int getResult()
    	{
    		return 0;
    	}
    	int m_Num1;
    	int m_Num2;
    };

    然后,写一个加法/减法/乘法计算器的类。继承于抽象类AbstractCalculator。其中重写虚函数virtual可带可不带。

    // 加法计算器类。
    class AddCalculator :public AbstractCalculator
    {
    public:
    	int getResult()
    	{
    		return m_Num1 + m_Num2;
    	}
    };
    
    // 减法计算器类
    class SubCalculator :public AbstractCalculator
    {
    public:
    	int getResult()
    	{
    		return m_Num1 - m_Num2;
    	}
    };
    class MultiCalculator :public AbstractCalculator
    {
    public:
    	int getResult()
    	{
    		return m_Num1 * m_Num2;
    	}
    };

    调用执行情况:

    void test01()
    {
    	// 多态的使用条件:
    	// 父类的指针或者引用,指向子类的对象。Animal animal = cat;
    	// 我们写一下:父类的指针指向子类对象。
    	AbstractCalculator* abc = new AddCalculator;   // 发生多态。
    	abc->m_Num1 = 20;
    	abc->m_Num2 = 30;
    	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
    	
    	// 因为这个对象是new出来的,存在堆区,手动开辟创建,手动释放。
    	delete abc;
    
    	abc = new SubCalculator;
    	abc->m_Num1 = 30;
    	abc->m_Num2 = 20;
    	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
    	delete abc;
    
    	abc = new MultiCalculator;
    	abc->m_Num1 = 30;
    	abc->m_Num2 = 20;
    	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
    	delete abc;
    }

    代码量变大了。

    多态带来的好处:

    1. 组织结构清晰。如果有一天发现:某个运算错了,比如加法。比如减法,马上可以定位到。而且只要修改这个类就行了,大型项目,列的越清晰越好。降低强耦合。
    2. 可读性强。一眼能看懂别人写的代码:并非你比别人强,而是写代码这个人厉害,让你一眼看懂。他也可以写成你看不懂的样子:那种样子叫做:恶心。
    3. 对于前期和后期的扩展以及维护性高。

    增加新功能:是追加代码,而不是修改原来的代码。



    这个案例是根据输入的运算符来操作运算。

    C#中的多态案例实现:

    C#学习笔记(二十一)之实现多态的手段

    C#中使用object作为参数来控制实现类型多态的。可以根据输入的两个对象类型,来选择不同运算。

    展开全文
  • 多态分为动态多态和静态多态。 静态多态:在运行前就决定函数调用的地址,也就是地址早绑定。 静态多态包括了:函数重载,运算符重载,和重定义。 分别阐述一下: 函数重载首先在同一个作用域当中,函数的名字相同,...
  • 的C++已经是个多重泛型编程语言(multiparadigm programming lauguage),一个同时支持过程形式(procedural)... C++支持多种形式的多态,从表现的形式来看,有虚函数、模板、重载等,从绑定时间来看,可以分成静态多态
  • 动态多态编程的好处 首先百度自己去弄懂什么是静态多态?什么是动态多态? 1,能使继承基类的子类重写(覆盖)基类定义的相同函数名字和参数的虚函数接口,使子类对象更符合自己的要求或特征一个简单粗暴的比喻就是假设...
  • 浅析动态多态原理

    2021-07-29 09:19:07
    多态分类及动态多态实现条件 先抛开严格的定义,所谓多态,顾名思义,就是多种形态。 多态分为两类:1.静态多态:函数重载和运算符重载 2.动态多态:派生类和虚函数实现运行时多态 动态多态实现有如下条件:1...
  • 顾名思义,动态多态,即在运行时,也即代码执行时表现出来的多种状态。 在语法层面,是通过使用virtual标记基类的函数,然后在派生类中重写此函数。在代码执行时,通过基类指针或引用的真实派生类型来调用派生类中...
  • 动态多态: 派生类和虚函数实现运行时多态 动态多态实现分三步:(代码中具体步骤用 【】标识) 子类重写父类的虚函数(类内实现) .父类指针指向子类对象(类外实现) .用该指针调用子类虚函数(类外实现) 案例一...
  • 之前学过继承,子类继承父类的属性,多态就是基于继承而来的,我们在如果只用继承,那么子类继承父类的各种...2、动态多态:派生类和虚函数实现运行时多态(运行期多态)。 函数重载就不必多说了,就是函数名的复用
  • 静态多态与动态多态

    2021-03-14 04:04:38
    面向对象编程的多态从绑定时间来看,可以分成静态多态和动态多态,也称为编译期多态和运行期多态。java中overload是静态多态,即根据参数列表进行最佳匹配,在编译阶段决定要具体执行哪个方法。而与之相反,overriden ...
  • C++动态多态

    2021-04-28 20:39:36
    多态又分为静态多态和动态多态,静态多态指的是在编译阶段就确定下来的内容,比如函数的重载 , 而动态多态指的是在运行时才能决定的事情,比如虚函数; 静态多态 静态多态指的是在编译阶段就确定下来的内容,比如...
  • 静态多态和动态多态 静态多态 静态多态也称为编译时多态,即在编译时决定调用哪个方法; 静态多态一般是指方法重戟; 只要构成了方法重载,就可以认为形成了静态多态的条件; 静态多态与是否发生继承没有必然联系 ...
  • 静态多态和动态多态的区别

    千次阅读 2020-12-30 14:46:07
    缺点: 由于是模板来实现静态多态,因此模板的不足也就是静多态的劣势,比如调试困难、编译耗时、代码膨胀、编译器支持的兼容性 不能够处理异质对象集合 动态多态 优点: OO设计,对是客观世界的直觉认识;...
  • 首先需要明确多态性的用途,是为了接口的最大程度复用,以及其定义: ...定义明确,接下来看看最常见的动态多态的实现思路:对于一组相关的数据类型,抽象出它们之间共同的功能集合,在基类中将共同的功
  • c++中的动态多态介绍及应用 1.多态的基本概念 **多态是c++面向对象的三大特性之一,那么什么是多态呢?**多态分为两类:静态多态和动态多态 1.1 静态多态 静态动态:函数重载和运算符重载,复用函数名 1.2 动态多态 ...
  • 面向对象语言C++三大特性之一——多态,分为静态多态和动态多态。 静态多态指重载,在编译期间就已经绑定,确定调用的函数。 动态多态就是编译时不确定将要调用的函数,因为虚函数的存在,子类重写父类的虚函数,...
  • C++---静态多态与动态多态

    万次阅读 多人点赞 2018-08-02 18:32:37
    动态多态 静态多态 静态多态:也称为编译期间的多态,编译器在编译期间完成的,编译器根据函数实参的类型(可能会进行隐式类型转换),可推断出要调用那个函数,如果有对应的函数就调用该函数,否则出现编译错误。 ...
  • 从上面的定义也可以看出,由于有了虚函数,因此动态多态是在运行时完成的,也可以叫做运行期多态,这造就了动态多态机制在处理异质对象集合时的强大威力(当然,也有了一点点性能损失)。 namespace DynamicPoly...
  • 【C++】—多态(上)动态多态

    千次阅读 2018-07-25 15:51:04
    一、多态 1、 概念:同一事物表现出的多种形态,同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。在运行时,可以通过指向基类的指针,来调用实现派生类中的方法。 2、 举例子: #include&...
  • 多态 基于继承和虚函数,多态的设计思想主要在于:对于几个相关对象的类型,确定它们之间的一个共同功能集;然后在基类中,把这些共同的功能声明为多个虚函数接口。每个具体类都派生自基类,生成了具体对象之后...
  • 动态多态的原理

    2018-04-05 12:37:37
    首先是多态的分类,分为静态多态和动态多态,也可以称为早绑定和晚绑定,区分的时刻就是程序在编译阶段根据参数个数确定调用哪个函数,如果能够确定就是早绑定如果不能确定就是晚绑定,如果要实现多态就必须要使用虚...
  • 并且多态分为静态多态和动态多态。 静态多态就是在系统编译期间就可以确定程序执行到这里将要执行哪个函数,例如:函数的重载,对象名加点操作符执行成员函数等,都是静态多态,其中,重载是在形成符号表的时候,对...
  • 静态多态 动态多态

    千次阅读 2018-04-15 19:00:38
    静态多态 1. 何为静态多态? 又称编译期多态,即在系统编译期间就可以确定程序将要执行哪个函数。例如:函数重载,通过类成员运算符指定的运算。 2. 示例代码 函数重载示例: class A { public: A() {} ...
  • C++多态性原理详解(静态多态、动态多态、虚函数、虚函数表) 先给出定义:多态是同一个行为具有多个不同表现形式或形态的能力。 1 联编 联编也称绑定,是指在一个源程序经过编译链接成为可执行文件的过程中,将可执行...
  • 动态多态:派生类和虚函数实现运行时多态。 静态多态和动态多态的区别: 静态多态的函数地址 早 绑定 —— 编译阶段确定函数地址。 动态多态的函数地址 晚 绑定 —— 运行阶段确定函数地址。 #include<...
  • 静态多态与动态多态的区别

    千次阅读 2020-04-22 20:16:51
    静态多态:函数入口地址是在编译阶段确定(运算符重载,函数重载) 动态多态:函数入口地址是在运行阶段确定(虚函数)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 135,971
精华内容 54,388
关键字:

动态多态

友情链接: examples.zip