精华内容
下载资源
问答
  • 本文阐述了静态联编动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。
  • 静态联编是指在编译阶段就将函数实现和函数调用关联起来,因此静态联编也叫早绑定,在编译阶段就必须了解所有的函数或模块执行所需要检测的信息,它对函数的选择是基于指向对象的指针(或者引用)的类型,C语言中,...
  • 中,要实现动态联编必须使用( 基类指针 )调用虚函数 联编是指一个计算机程序自身彼此关联的过程。按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编动态联编。编译程序在编译阶段并不能确切...

    C++中,要实现动态联编,必须使用(基类指针)调用虚函数

    联编是指一个计算机程序自身彼此关联的过程。按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编和动态联编。编译程序在编译阶段并不能确切知道将要调用的函数,只有在程序执行时才能确定将要调用的函数,为此要确切知道该调用的函数,要求联编工作要在程序运行时进行,这种在程序运行时进行联编工作被称为动态联编,或称动态束定,又叫晚期联编。C++规定动态联编是在虚函数的支持下实现的。

    展开全文
  • C++之动态联编

    千次阅读 2020-04-02 21:31:09
    成为一个可执行程序)的过程,在这个联编过程中,需要确定程序中的操作调用(函数调用)与执行该操作(函数)的代码段之间的映射关系,按照联编所进行的阶段不同,可分为静态联编动态联编。 静态联编 静态联编又...

    首先来看看百度百科的联编定义:

    联编是指一个计算机程序自身彼此关联(使一个源程序经过编译、连接,成为一个可执行程序)的过程,在这个联编过程中,需要确定程序中的操作调用(函数调用)与执行该操作(函数)的代码段之间的映射关系,按照联编所进行的阶段不同,可分为静态联编和动态联编。

    静态联编

    静态联编又称静态束定、早期联编、前期联编。

    静态联编是指联编工作是在程序编译连接阶段进行的,静态联编又称早期联编,因为这种联编是在程序开始运行之前完成的。在程序编译阶段进行的这种联编又称静态束定,在编译时就解决了程序中的操作调用与执行该操作代码间的关系,确定这种关系又被称为束定,编译时束定又称为静态束定。

    特点:

    调用速度快,效率高。

    动态联编

    动态联编又称动态关联、动态束定、后期联编、晚期联编。

    动态联编是指编译程序在编译阶段并不能确切地知道将要调用的函数,只有在程序执行时才能确定将要调用的函数,为此要确切地知道将要调用的函数,要求联编工作在程序运行时进行,这种在程序运行时进行的联编工作被称为动态联编。C++规定:动态联编是在虚函数的支持下实现的。

    动态联编必须包括以下方面:

    1、成员函数必须声明为virtual

    2、如果基类中声明了为虚函数,则派生类中不必再声明。

    调用方式:

    通过对象的指针引用调用成员函数,或通过成员函数调用,反之就无法实现动态联编。

    特点:

    灵活,问题抽象性和问题的易维护性。

     

    百度百科真是越写越好了,继续加油。

     

    动态联编在运行时确定了使用基类还是子类的函数,这就是C++实现多态的手段。从本质上来讲,多态是想是实现模板编程,这种思想在我看来既能说是面向对象的特征,也可以说是一种新的编程思路。尽可能的实现代码复用,或者说是一个方法名称实现某一种类似行为。

    #include<iostream>
    
    using std::cout;
    using std::endl;
    
    class Parent
    {
    public:
    	virtual void show()        //虚函数show
    	{
    		cout << "parent" << endl;
    	}
    };
    
    class Son : public Parent
    {
    public:
    	void show()
    	{
    		cout << "son" << endl;
    	}
    };
    
    void fun(Parent& p)
    {
    	p.show();
    }
    
    int main()
    {
    	Parent* p = nullptr;
    	p = new Son;
    
    	Parent p1;
    
    	fun(p1);			//父类
    	fun(*p);			//子类
    
    	delete p;
    	p = nullptr;
    
    	return 0;
    }

    fun的参数是p1的时候,将会调用父类的show函数,而参数是*p的时候会调用子类的show函数。这就动态联编,这运行的时候确定是哪一个函数。

    作为参照,我们来看看静态联编的效果。

    #include<iostream>
    
    using std::cout;
    using std::endl;
    
    class Parent
    {
    public:
    	virtual void show()			//虚函数show
    	{
    		cout << "parent" << endl;
    	}
    	void put()
    	{
    		cout << "基类" << endl;
    	}
    };
    
    class Son : public Parent
    {
    public:
    	void show()
    	{
    		cout << "son" << endl;
    	}
    
    	void put()
    	{
    		cout << "派生类" << endl;
    	}
    };
    
    void fun(Parent& p)
    {
    	p.show();
    }
    
    void fun(Parent& p,int)			//使用占位参数重载fun。
    {
    	p.put();
    }
    
    int main()
    {
    	Parent* p = nullptr;
    	p = new Son;
    
    	Parent p1;
    
    	fun(p1);			//父类
    	fun(*p);			//子类
    		
    	cout << endl;
    
    	fun(p1, 1);			//父类
    	fun(*p, 1);			//子类
    
    	delete p;
    	p = nullptr;
    
    	return 0;
    }

    结果如下:

    很明显,静态联编在编译的时候就和被调函数绑定了,只会去调用基类的put成员函数,根本不会调用派生类重写的put成员。

    基类一般把派生类需要重定义的任意函数定义为虚函数。

    除了构造函数和static成员函数之外,其余的函数都可以被virtual修饰成为虚函数。

    一旦有了虚函数,那么就将发生多态。

     

    展开全文
  • 按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编动态联编。 1. 静态联编        静态联编是指联编工作在编译阶段完成的,这种联编过程是在程序运行...

    &nbsp
           在C++中,联编是指一个计算机程序的不同部分彼此关联的过程。按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编和动态联编。

    1. 静态联编

           静态联编是指联编工作在编译阶段完成的,这种联编过程是在程序运行之前完成的,又称为早期联编。要实现静态联编,在编译阶段就必须确定程序中的操作调用(如函数调用)与执行该操作代码间的关系,确定这种关系称为束定,在编译时的束定称为静态束定。静态联编对函数的选择是基于指向对象的指针或者引用的类型。其优点是效率高,但灵活性差。

    例1:静态联编

    #include"iostream.h"
    
    class A{
    public:
     
     voidf(){cout<<"A"<<"";}
    };
    
    classB:publicA{
    public:
    
     voidf(){cout<<"B"<<endl;}
    };
    
    Void main(){
    
    A*pa=NULL;
    Aa;Bb;
    
    pa=&a;pa->f();
    pa=&b;pa->f();
    }
    
    该程序的运行结果为:A   A
    

           从例1程序的运行结果可以看出,通过对象指针进行的普通成员函数的调用,仅仅与指针的类型有关,而与此刻指针正指向什么对象无关。要想实现当指针指向不同对象时执行不同的操作,就必须将基类中相应的成员函数定义为虚函数,进行动态联编。

    2. 动态联编

           动态联编是指联编在程序运行时动态地进行,根据当时的情况来确定调用哪个同名函数,实际上是在运行时虚函数的实现。这种联编又称为晚期联编,或动态束定。动态联编对成员函数的选择是基于对象的类型,针对不同的对象类型将做出不同的编译结果。C++中一般情况下的联编是静态联编,但是当涉及到多态性和虚函数时应该使用动态联编。动态联编的优点是灵活性强,但效率低。

           动态联编规定,只能通过指向基类的指针或基类对象的引用来调用虚函数,其格式为:

    指向基类的指针变量名->虚函数名(实参表)
    或 基类对象的引用名.虚函数名(实参表)
    

    实现动态联编需要同时满足以下三个条件:

    ① 必须把动态联编的行为定义为类的虚函数。

    ② 类之间应满足子类型关系,通常表现为一个类从另一个类公有派生而来。

    ③ 必须先使用基类指针指向子类型的对象,然后直接或者间接使用基类指针调用虚函数。

    例2:动态联编

    #include"iostream.h"
    
    classA{
    public:
    	Virtual voidf()//虚函数
    	{ 
    	cout<<"A"<<""; 
    	}
    };
    
    classB:publicA {
    public:
    
    	Virtual voidf()//虚函数
    	{
    	cout<<"B"<<endl;
    	}
    };
    
    void main(){ 
    	A*pa=NULL;
    	Aa;Bb;
    
    	pa=&a;
    	pa->f();
    	pa=&b;
    	pa->f();
    }
    

    该程序的运行结果为:A B

           从例2程序的运行结果可以看出,将基类A中的函数f定义为虚函数后,当指针指向不同对象时执行了不同的操作,实现了动态联编。

           虚函数是实现多态的基础,是实现动态联编的必要条件之一。动态联编要靠虚函数来实现,虚函数要靠动态联编的支持。两者相辅相成,缺一不可。

    展开全文
  • 动态联编与静态联编的区别

    千次阅读 2019-03-18 14:40:57
    摘要】:本文阐述了静态联编动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编动态联编;虚函数 在C++中,联编是指一个计算机程序的...

     摘要】:本文阐述了静态联编和动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。

    【关键词】:静态联编;动态联编;虚函数

    在C++中,联编是指一个计算机程序的不同部分彼此关联的过程。按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编和动态联编。

        1. 静态联编

     

    静态联编是指联编工作在编译阶段完成的,这种联编过程是在程序运行之前完成的,又称为早期联编。要实现静态联编,在编译阶段就必须确定程序中的操作调用(如函数调用)与执行该操作代码间的关系,确定这种关系称为束定,在编译时的束定称为静态束定。静态联编对函数的选择是基于指向对象的指针或者引用的类型。其优点是效率高,但灵活性差。

     

    例1:静态联编

    #include"iostream.h"

    class A

    {public:

     voidf(){cout<<"A"<<"";}

    };

    classB:publicA

    {public:

     voidf(){cout<<"B"<<endl;}

    };

    Void main()

    {A*pa=NULL;

    Aa;Bb;

    pa=&a;pa->f();

    pa=&b;pa->f();

    }

    该程序的运行结果为:A   A

    从例1程序的运行结果可以看出,通过对象指针进行的普通成员函数的调用,仅仅与指针的类型有关,而与此刻指针正指向什么对象无关。要想实现当指针指向不同对象时执行不同的操作,就必须将基类中相应的成员函数定义为虚函数,进行动态联编。

     

    2. 动态联编

    动态联编是指联编在程序运行时动态地进行,根据当时的情况来确定调用哪个同名函数,实际上是在运行时虚函数的实现。这种联编又称为晚期联编,或动态束定。动态联编对成员函数的选择是基于对象的类型,针对不同的对象类型将做出不同的编译结果。C++中一般情况下的联编是静态联编,但是当涉及到多态性和虚函数时应该使用动态联编。动态联编的优点是灵活性强,但效率低。

    动态联编规定,只能通过指向基类的指针或基类对象的引用来调用虚函数,其格式为:指向基类的指针变量名->虚函数名(实参表)或基类对象的引用名.虚函数名(实参表)

    实现动态联编需要同时满足以下三个条件:

    ①    必须把动态联编的行为定义为类的虚函数。

    ②    类之间应满足子类型关系,通常表现为一个类从另一个类公有派生而来。

    ③    必须先使用基类指针指向子类型的对象,然后直接或者间接使用基类指针调用虚函数。

    例2:动态联编

    #include"iostream.h"

    classA

    {public:

    Virtual voidf()//虚函数

    {cout<<"A"<<"";}};

    classB:publicA

    {public:

    Virtual voidf()//虚函数

    {cout<<"B"<<endl;}

    };

    voidmain()

    { A*pa=NULL;

    Aa;Bb;

    pa=&a;

    pa->f();

    pa=&b;

    pa->f();

    }

    该程序的运行结果为:A  B

    从例2程序的运行结果可以看出,将基类A中的函数f定义为虚函数后,当指针指向不同对象时执行了不同的操作,实现了动态联编。

    3. 动态联编分析

     动态联编要求派生类中的虚函数与基类中对应的虚函数具有相同的名称、相同的参数个数和相同的对应参数类型、返回值或者相同,或者都返回指针或引用,并且派生类虚函数所返回的指针或引用的基类型是基类中虚函数所返回的指针或引用的基类型的子类型。如果不满足这些条件,派生类中的虚函数将丢失其虚特性,在调用时进行静态联编。

    例3:通过指向基类的指针来调用虚函数

    #include"iostream.h"

    Class base

    {

    public:

    virtual void fun1(){cout<<"base fun1"<<endl;}

    virtual void fun2(){cout<<"base fun2"<<endl;}

    void fun3(){cout<<"base fun3"<<endl;}

    void fun4(){cout<<"base fun4"<<endl;}

    };

    Class derived:public base

    {public:

    Virtual void fun1(){cout<<"derived fun1"<<endl;}

    Virtual void fun2(intx){cout<<"derived fun2"<<endl;}

    Virtual void fun3(){cout<<"derived fun3"<<endl;}

    Void fun4(){cout<<"derived fun4"<<endl;}};

    Void main()

    {base*pb;

    derivedd;

    pb=&d;//通过指向基类的指针来调用虚函数pb->fun1();pb->fun2();pb->fun3();pb->fun4();}

    该程序的运行结果:

    Derived fun1 base fun2 base fun3 base fun4

     

    本例中函数fun1在基类base和派生类derived中均使用了关键字virtual定义为虚函数,并且这两个虚函数具有相同的参数个数、参数类型和返回值类型。因此,当指针pb访问fun1函数时,采用的是动态联编。函数fun2在基类base和派生类de-rived中定义为虚函数,但这两个虚函数具有不同的参数个数。函数fun2丢失了其虚特性,在调用时进行静态联编。函数fun3在基类base中说明为一般函数,在派生类derived中定义为虚函数。在这种情况下,应该以基类中说明的成员函数的特性为标准,即函数fun3是一般成员函数,在调用时采用静态联编。函数fun4在基类base和派生类derived中均说明为一般函数,因此基类指针pb只能访问base中的成员。

     

     

    例4:通过基类对象的引用来调用虚函数

    #include"iostream.h"

    Class CPoint

    {public:

    CPoint(doublei,doublej){x=i;y=j;}

    Virtual double Area(){return 0.0;}

    private:

    doublex,y;

    };

    Class CRectangle:public CPoint

    {public:

    CRectangle(double i,double j,double k,double l);

    Double Area(){return w*h;}

    private:

    double w,h;

    };

    CRectangle::CRectangle(double i,double j,double k,double l):CPoint(i,j)

    {  w=k;h=l;  }

    Void fun(CPoint &s)

    {  cout<<s.Area()<<endl;  }//通过基类对象的引用来调用虚函数

    Void main()

    {

    CRectangle rec(3.0,5.2,15.0,25.0);

    fun(rec);

    }

    该程序的运行结果为:375

     例4中的成员函数Area在基类CPoint中使用了关键字virtual定义为虚函数,在派生类CRectangle中定义为一般函数,但是进行了动态联编,结果为15*25即375。这是因为一个虚函数无论被公有继承多少次,它仍然保持其虚特性。在派生类中重新定义虚函数时,关键字virtual可以写也可不写,但为了保持良好的编程风格,避免引起混乱时,应写上该关键字。

    4. 小结

        从以上四个例子中可以看出:虚函数是实现多态的基础,是实现动态联编的必要条件之一。动态联编要靠虚函数来实现,虚函数要靠动态联编的支持。两者相辅相成,缺一不可

     

    转自:https://blog.csdn.net/neiloid/article/details/6934129

    展开全文
  • 动态联编与静态联编

    2016-08-15 10:29:58
    要实现静态联编,在编译阶段就必须确定程序中的操作调用(如函数调用)与执行该操作代码间的关系,确定这种关系称为束定,在编译时的束定称为静态束定。静态联编对函数的选择是基于指向对象的指针或者引用的类型。其...
  • 静态联编动态联编

    千次阅读 2020-03-08 16:02:43
    在C++中,由于重载的缘故,编译器必须查看函数参数以及函数名才能确定使用的是哪个函数,然而睡佳佳编译器可以在编译过程中完成这种两边在编译过程中进行联编,被称为静态联编。虚函数是这项工作变得更加困难,使用...
  • 静态联编动态联编

    2019-05-05 15:49:57
    2、静态联编(static binding),是程序的匹配、连接在编译阶段实现,也称为早期匹配。 重载函数使用静态联编。(没有加virtual) 3、动态联编是指程序联编推迟到运行时进行,所以又称为晚期联编(迟绑定)。(加...
  • C++ 动态联编实现原理分析

    千次阅读 2015-11-17 19:25:46
    C++标准并没有规定如何实现动态联编,但大多数的C++编译器都是通过虚指针(vptr)和虚函数表(vtable)来实现动态联编。 基本的思路是: (1)为每一个包含虚函数的类建立一个虚函数表,虚函数表的每一个表项...
  • 多态,顾名思义“ 多种状态”,在面向对象语言中,接口的多种不同实现方式即为多态。 也就是允许将子类类型的指针赋值给父类类型的指针。 class A{public: A(); virtual void k(){ qDebug()"aaaaaaaaa"; }}; ...
  • 摘要】:本文阐述了静态联编动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编动态联编;虚函数 在C++中,联编是指一个计算机...
  • 关于静态联编动态联编的分析

    千次阅读 2013-06-14 09:44:57
    在C++中,联编是指一个计算机程序的不同部分...要实现静态联编,在编译阶段就必须确定程序中的操作调用(如函数调用)与执行该操作代码间的关系,确定这种关系称为束定,在编译时的束定称为静态束定。静态联编对函数
  • 动态联编和静态联编

    2017-05-23 16:05:31
    静态联编动态联编;虚函数 在C++中,联编是指一个计算机程序的不同部分彼此关联的过程。...要实现静态联编,在编译阶段就必须确定程序中的操作调用(如函数调用)与执行该操作代码间的关系,确定这种关系称为束
  • C++ 虚函数、静态联编动态联编

    千次阅读 2016-01-05 17:12:04
    本文将对c++虚函数做个总结。...纯虚函数在基类中是没有定义的,必须在子类中加以实现,很像java中的接口函数! 虚函数 引入原因:为了方便使用多态特性,我们常常需要在基类中定义虚函数。 class C
  • 在C++中,联编是指一个计算机程序的不同部分彼此关联的过程...要实现静态联编,在编译阶段就必须确定程序中的操作调用(如函数调用)与执行该操作代码间的关系,确定这种关系称为束定,在编译时的束定称为静态束定。静
  • 为什么用指针或引用, 为什么用基类指向派生类, 动态联编的好处。
  • C++静态联编动态联编

    千次阅读 多人点赞 2018-12-06 09:15:28
    就是将模块或者函数合并在一起生成可执行代码的处理过程(函数调用),按照联编所进行的阶段不同,可分为两种不同的联编方式:静态联编动态联编。 函数调用和实现的过程 C++只有用到多态才会用到动态连编 程序员...
  • 多态性是C++最主要的特征,多态性的实现得益于C++中的动态联编技术。文章通过对动态联编的关键技术虚拟函数表进行深入的剖析,解析的动态联编的过程极其技术要领。
  • C++:静态联编动态联编

    千次阅读 2016-09-07 16:00:53
    C++:静态联编动态联编标签(空格分隔): c++C静态联编动态联编 指针和引用类型的兼容性 虚拟成员和动态编联 为什么C中默认的编联方式是静态编联 动态编联如何工作 注意事项 友元 没有重定义 重新定义将隐藏...
  • C++基础---静态联编动态联编

    千次阅读 2015-09-04 16:29:10
    1. 静态联编动态联编 1.1 函数联编的定义 函数联编:将一个调用函数者联结上正确的被调用函数的过程,一般称为联编。 C++中的联编分两种: (1)静态联编; (2)动态联编; 1.2 静态联编的定义 成员函数必须声明...
  • 动态联编 和 静态联编

    万次阅读 多人点赞 2012-12-15 11:06:43
    关于 动态联编 和 静态联编 这个概念,自己听了老师上课讲的课仍然没有明白原理。...首先我们从概念性上面了解了 动态联编 和 静态联编 的功能:实现了多态性。 然后我们从最最基本的开始讲解。 1.什么
  • 联编指的是用于实现和达到多态的一种方式方法. 多态:通过多种形态表现出来. 种类:如函数重载: 通过令传入函数的参数列表中的 参数个数不同, 类型不同, 顺序不同 使得函数名有多种形态来表现 静态多态: 如函数重载和...
  • 在编译时的动态联编 在运行时的动态联编 C++中的虚函数在这篇:《随笔九》—— C++中的 “ 虚函数 ”https://blog.csdn.net/qq_34536551/article/details/84375823 下面先给出一些代码示例,引用出使用多态的...
  • C++虚函数与动态联编

    千次阅读 2017-07-11 19:54:37
    静态联编动态联编  编译器将源代码中的函数调用解释为执行特定的函数代码块,这一行为被称为函数名联编(binding)。联编行为发生在编译过程中则被称为静态联编(static binding),又称为早期联编(early ...
  • 下面小就为大家带来一篇mysql 行列动态转换的实现(列表,交叉表)。小觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小过来看看吧
  • 动态联编

    千次阅读 多人点赞 2015-10-08 20:38:37
    关于 动态联编 和 静态联编 这个概念,自己听了老师上课讲的课仍然没有明白原理。 ...首先我们从概念性上面了解了 动态联编 和 静态联编 的功能:实现了多态性。 然后我们从最最基本的开

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,629
精华内容 9,851
关键字:

要实现动态联编必须