精华内容
下载资源
问答
  • 静态多态

    2019-09-26 17:23:34
    #include <...// 静态多态 可以用函数重载实现,或,模板 class CBeer { public: void Show() { cout << "CBeer::Show" << endl; } }; class CMilk { public: void Show() { ...
    #include <iostream>
    using namespace std;
    //  静态多态 可以用函数重载实现,或,模板
    class CBeer
    {
    public:
    	void Show()
    	{
    		cout << "CBeer::Show" << endl;
    	}
    };
    
    class CMilk
    {
    public:
    	void Show()
    	{
    		cout << "CMilk::Show" << endl;
    	}
    };
    
    
    class CCoffee 
    {
    public:
    	void Show()
    	{
    		cout << "CCoffee::Show" << endl;
    	}
    };
    
    void Bottle(CBeer* p)
    {
    	p->Show();
    }
    void Bottle(CMilk* p)
    {
    	p->Show();
    }
    void Bottle(CCoffee* p)
    {
    	p->Show();
    }
    
    
    int main()
    {
    	CBeer* beer = new CBeer;
    	CMilk* milk = new CMilk;
    	CCoffee* coffee = new CCoffee;
    
    	Bottle(beer);
    	Bottle(milk);
    	Bottle(coffee);
    
    
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 0. 提出问题 什么是多态? 多态按字面的意思就是多种形态。...例如:函数的重载,对象名加点操作符执行成员函数,类成员运算符指定的运算等,都是静态多态,其中,重载是在形成符号表的时候,对...

    0. 提出问题

    什么是多态?

    多态按字面的意思就是多种形态。当类之间存在层次结构,并且类之间是通过继承关联时,就会用到多态。

    多态氛围哪几类?

    多态可以分为静态多态和动态多态。

    1. 静态多态

    又称编译期多态,即在系统编译期间就可以确定程序将要执行哪个函数。例如:函数的重载,对象名加点操作符执行成员函数,类成员运算符指定的运算等,都是静态多态,其中,重载是在形成符号表的时候,对函数名做了区分,从而确定了程序执行到这里将要执行哪个函数,对象名加点操作符执行成员函数和类成员运算符指定的运算是通过this指针来调用的。

    class A {
    public:
        A(){}
        void fun(){}
        void fun(int x){
            val = x;
        }
    private:
        int val;
    };
    
    int main(){
        A a;
        a.fun();
        a.fun(10);
        return 0;
    }

    这里定义了一个A类,有一个成员函数和一个成员,我们将程序的部分汇编代码截取出来如下图: 

     

    我们可以看到这里直接是一个lea指令将a对象的地址放入寄存器eax中,也就是对象的this指针,然后用call指令就可以跳转到Set函数,也就是说其汇编代码在此时就知道应该要去到哪个地方之行哪个函数,这就是静态多态,也叫编译时多态

    2. 动态多态 

    #include<iostream>
    using namespace std;
    class A {
    public:
    	A(int a = 10) :_a(a) {}
    	virtual void Get() {
    		cout << "A:: _a=" << _a << endl;
    	}
    public:
    	int _a;
    };
    
    class B : public A {
    public:
    	B(int b = 20) :_b(b) {}
    	void Get() {
    		cout << "B:: _b=" << _b << endl;
    	}
    public:
    	int _b;
    };
    
    int main() {
    	A a1;
    	B b1;
    	A* ptr1 = &a1;
    	ptr1->Get();
    	ptr1 = &b1;
    	ptr1->Get();
    	return 0;
    }
    /*
    输出结果:
    A:: -a=10
    B:: _b=20
    */
    

    这说明确实是实现了不同调用,而且是在运行时,那么虚函数的底层到底是怎么实现的呢,我们来看一下汇编代码及其对象模型

    通过上图的汇编代码,我们看到这里做了一系列的指针解引用处理,最后确定了eax中应该存放的this指针的值,要搞清楚这个必须要搞清楚子类的对象模型。

     

    展开全文
  • 静态多态和动态多态 静态多态 静态多态也称为编译时多态,即在编译时决定调用哪个方法; 静态多态一般是指方法重戟; 只要构成了方法重载,就可以认为形成了静态多态的条件; 静态多态与是否发生继承没有必然联系 ...

    静态多态和动态多态


    静态多态

    • 静态多态也称为编译时多态,即在编译时决定调用哪个方法;
    • 静态多态一般是指方法重戟;
    • 只要构成了方法重载,就可以认为形成了静态多态的条件;
    • 静态多态与是否发生继承没有必然联系

    如下所示:

    void test(int a){ cout << "1" << endl; }
    void test(int a,int y){ cout << "2" << endl; }
    void test(int a,int y,int z){ cout << "2" << endl; }
    int main()
    {
        test(1);
        test(1, 2);
        test(1, 2, 3);

    虽然调用的三个函数名字相同,但是在编译的时候已经直到调用的是哪一个函数。

    编译前已经知道了对同一函数的不同响应。


    动态多态

    • 动态多态也称为运行时多态,即在运行时才能确定调用哪个方法;
    • 形成动态多态必须具体以下条件:继承是实现动态多态的首要前提
    • 在继承中必须要有方法覆盖;
    • 必须由基类的引用指向派生类的实例,并且通过基类的引用调用被覆盖的方法。

    这个地方引用的是我另一篇博客的代码。

    即将animal作为基类,然后产生三个派生类cat类,dog类,pig类,并定义出一个animal数组,数组的每个位置都是基类和派生类之间转化而来的。

    此时在编译的时候,数组的三个位置都调用show函数时,不能里面分辨出是哪个类对象的show函数,之后在运行时才知道,这种就叫做动态多态。

    #include<iostream>
    using namespace std;
    
    class animal
    {
    public:
    	virtual void show()
    	{
    		cout << "我是animal类" << endl;
    	}
    };
    
    class dog :public animal
    {
    public:
    	void show()
    	{
    		cout << "我是dog类" << endl;
    	}
    };
    
    class cat :public animal
    {
    public:
    	void show()
    	{
    		cout << "我是cat类" << endl;
    	}
    };
    
    class pig :public animal
    {
    public:
    	void show()
    	{
    		cout << "我是pig类" << endl;
    	}
    };
    
    int main()
    {
    	cat a; dog b; pig c;
    	animal *x[3] = { &a, &b, &c };
    	
    	for (int i = 0; i < 3; i++)
    	{
    		x[i]->show();
    	}
    	system("pause");
    	return 0;
    }

    比较

    静态多态

    优点:

    1. 由于静多态是在编译期完成的,因此效率较高,编译器也可以进行优化;
    2. 有很强的适配性和松耦合性,比如可以通过偏特化、全特化来处理特殊类型;
    3. 最重要一点是静态多态通过模板编程为C++带来了泛型设计的概念,比如强大的STL库。

    缺点:

    1. 由于是模板来实现静态多态,因此模板的不足也就是静多态的劣势,比如调试困难、编译耗时、代码膨胀、编译器支持的兼容性
    2. 不能够处理异质对象集合

    动态多态

    优点:

    1. OO设计,对是客观世界的直觉认识;
    2. 实现与接口分离,可复用
    3. 处理同一继承体系下异质对象集合的强大威力

    缺点:

    1. 运行期绑定,导致一定程度的运行时开销;
    2. 编译器无法对虚函数进行优化
    3. 笨重的类继承体系,对接口的修改影响整个类层次;

    不同点:

    1. 本质不同,静态多态在编译期决定,由模板具现完成,而动态多态在运行期决定,由继承、虚函数实现;
    2. 动态多态中接口是显式的,以函数签名为中心,多态通过虚函数在运行期实现,静态多台中接口是隐式的,以有效表达式为中心,多态通过模板具现在编译期完成

    相同点:

    1. 都能够实现多态性,静态多态/编译期多态、动态多态/运行期多态;
    2. 都能够使接口和实现相分离,一个是模板定义接口,类型参数定义实现,一个是基类虚函数定义接口,继承类负责实现;

     

    展开全文
  • 多态分为静态多态和动态多态。 1.静态多态静态多态又称编译期多态:是指在**编译阶段就知道程序执行到这里接下来会执行哪个函数。**例如:函数重载,对象名加点操作符执行函数等都是静态多态。函数重载是函数名...

    多态:即多种形态。对不同对象发送同一消息,不同对象会做出不同的响应。多态分为静态多态和动态多态。
    1.静态多态:
    静态多态又称编译期多态:是指在**编译阶段就知道程序执行到这里接下来会执行哪个函数。**例如:函数重载,对象名加点操作符执行函数等都是静态多态。函数重载是函数名修饰规则从而确定执行哪个函数,而对象名加点操作符是通过this指针来确定的。
    2.动态多态:
    动态多态是利用虚函数实现运行时的多态,即在编译期并不知道接下来执行哪条语句,只有运行到这里才知道接下来要调用哪个函数。
    实现动态多态的条件:
    1.函数在基类中声明为虚函数,并且在派生类中重写;
    2.对象的父类指针或引用,如果对象指向子类(子类对象的引用/指针赋给基类对象引用/指针),则调子类的虚函数;如果对象指向父类对象,则调父类的虚函数。

    class A
    {
    public:
    	virtual void func1()
    	{
    		cout << "A::func1()" << endl;
    	}
    	void display()
    	{
    		cout << "A::display()" << endl;
    	}
    	void display(int i)
    	{
    		cout << "A::display(int i)" << endl;
    	}
    protected:
    	int _a;
    };
    
    class B : public A
    {
    public:
    	virtual void func1()
    	{
    		cout << "B::func1()" << endl;
    	}
    protected:
    	int _b;
    };
    
    void func(A& a)
    {
    	a.func1(); //动态多态
    	a.display();  //函数重载 即静态多态
    	a.display(10);
    }
    
    
    int main()
    {
    	A a;
    	B b;
    	func(a);
    	func(b);
    	system("pause");
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • C++---静态多态与动态多态

    万次阅读 多人点赞 2018-08-02 18:32:37
    静态多态:也称为编译期间的多态,编译器在编译期间完成的,编译器根据函数实参的类型(可能会进行隐式类型转换),可推断出要调用那个函数,如果有对应的函数就调用该函数,否则出现编译错误。 静态多态有两种实现...
  • C++多态——静态多态与动态多态

    万次阅读 多人点赞 2017-02-16 16:01:54
    静态多态就是在系统编译期间就可以确定程序执行到这里将要执行哪个函数,例如:函数的重载,对象名加点操作符执行成员函数等,都是静态多态,其中,重载是在形成符号表的时候,对函数名做了区分,从而确定了程序执行...
  • 的C++已经是个多重泛型编程语言(multiparadigm programming lauguage),一个同时支持过程形式(procedural)... C++支持多种形式的多态,从表现的形式来看,有虚函数、模板、重载等,从绑定时间来看,可以分成静态多态
  • 多态分为动态多态和静态多态静态多态:在运行前就决定函数调用的地址,也就是地址早绑定。 静态多态包括了:函数重载,运算符重载,和重定义。 分别阐述一下: 函数重载首先在同一个作用域当中,函数的名字相同,...
  • 静态多态 动态多态

    千次阅读 2018-04-15 19:00:38
    静态多态 1. 何为静态多态? 又称编译期多态,即在系统编译期间就可以确定程序将要执行哪个函数。例如:函数重载,通过类成员运算符指定的运算。 2. 示例代码 函数重载示例: class A { public: A() {} ...
  • C++的两种多态形式:静态多态 & 动态多态 静态多态 静态多态:也称为编译期间的多态,编译器在编译期间完成的,编译器根据函数实参的类型推断出要调用那个函数,如果有对应的函数就调用该函数,否则出现编译...
  • 静态多态和动态多态

    千次阅读 2017-03-16 16:08:57
    面向对象编程的多态从绑定时间来看,可以分成静态多态和动态多态,也称为编译期多态和运行期多态。 应用形式上: 静多态是发散式的,让相同的实现代码应用于不同的场合。 动多态是收敛式的,让不同的实现...
  • 静态多态与动态多态

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

    2020-04-18 21:28:09
    两者本质不同,静态多态在编译期决定,由模板具现完成,而动态多态在运行期决定,由继承、虚函数实现; 所谓联编就是将函数的调用和函数的定义联系起来。 分为静态联编和动态联编; 静态联编: 指在程序编译连接...
  • C++ 静态多态

    2021-06-19 15:51:02
    多态是面向对象的基本思想。一般情况下,我们会采用虚函数和虚函数表的方式实现...对于这种情况,我们不需要虚函数表,可以采用静态多态,一般通过crtp技术来实现静态多态。 当然,在一些需求下,比如迭代的访问vect
  • 1.静态多态 2.动态多态
  • 静态多态和CRTP

    2020-04-02 16:29:30
    千万不要忘记多态还有静态多态 静态多态有:1.函数重载。2.模板方法 CRTP也是一种实现静态多态的方法: template<typename T> class Base { public: void method() { static_cast<T*>(this)->...
  • 静态多态就是在系统编译期间就可以确定程序执行到这里将要执行哪个函数,例如:函数的重载,对象名加点操作符执行成员函数等,都是静态多态,其中,重载是在形成符号表的时候,对函数名做了区分,从而确定了程序执行...
  • c++中静态多态和动态多态的区别 静态多态的函数地址早绑定,编译阶段确定函数地址 动态多态的函数地址晚绑定,运行阶段确定函数地址
  • 静态多态: 编译阶段确定函数地址 (如:函数重载) 动态多态:运行过程中确定函数地址 (子类重写父类虚函数)
  • 静态多态与动态多态的区别

    千次阅读 2020-04-22 20:16:51
    静态多态:函数入口地址是在编译阶段确定(运算符重载,函数重载) 动态多态:函数入口地址是在运行阶段确定(虚函数)
  • 静态多态就是在系统编译期间就可以确定程序执行到这里将要执行哪个函数,例如:函数的重载,对象名加点操作符执行成员函数等,都是静态多态,其中,重载是在形成符号表的时候,对函数名做了区分,从而确定了程序执行...
  • C++中的多态分为两种:静态多态与动态多态 一、静态多态:也成为编译时的多态;在编译时期就已经确定要执行了的函数地址了;主要有函数重载和函数模板(这里只写函数重载) (1)函数重载 因为C++中确定执行的函数...
  • C++的动态多态和静态多态

    千次阅读 2013-03-12 11:20:05
    Static and Dynamic Polymorphism in C++ ...述了这种相似性 并重点论述了以模板实现的静态多态的应用范围 关键词 动态多态 静态多态 模板多态 概念 模型 标准模板库 但是应用范围不同
  • 静态多态(编译期/早绑定) 函数重载 class A { public: void do(int a); void do(int a, int b); }; 动态多态(运行期期/晚绑定) •虚函数:用 virtual 修饰成员函数,使其成为虚函数 注意: •普通函数(非类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,861
精华内容 55,544
关键字:

静态多态