精华内容
下载资源
问答
  • 本文阐述了静态联编动态联编的概念和区别,通过具体实例分析了实现动态联编条件,指出了虚函数是实现动态联编的基础。
  • 按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编动态联编。 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

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

    千次阅读 2020-03-08 16:02:43
    将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编。 在c语言中,因为每个函数名都有对应一个不同的函数。在C++中,由于重载的缘故,编译器必须查看函数参数以及函数名才能确定使用的是哪个函数,...

    将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编。

    在c语言中,因为每个函数名都有对应一个不同的函数。在C++中,由于重载的缘故,编译器必须查看函数参数以及函数名才能确定使用的是哪个函数,然而睡佳佳编译器可以在编译过程中完成这种两边在编译过程中进行联编,被称为静态联编。虚函数是这项工作变得更加困难,使用哪一个函数不是是不能在编译的时候确定的,因为编译器不就多少用户将选择哪种类型的对象,所以编译器必须生成能够在运行程序中时选择正确的序方法的代码,这种称为动态联编

    1.静态联编

    静态联编对函数的选择是基于指向对象的指针或者引用的类型。其优点是效率高,但灵活性差。

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

    class A
    {
    public:
    	void f() { cout << "A" << " "; }
    };
    
    class B :public A
    {
    public:
    	void f() { cout << "B" << endl; }
    };
    
    void main()
    {
    	A *pa;A a; B b;
    
    	pa = &a;
    	pa -> f();
    
    	pa = &b;
    	pa -> f();
    }
    

    2.动态联编

    动态联编是指联编在程序运行时动态地进行,根据当时的情况来确定调用哪个同名函数,实际上是在运行时虚函数的实现。动态联编对成员函数的选择是基于对象的类型,针对不同的对象类型将做出不同的编译结果。C++中一般情况下的联编是静态联编,但是当涉及到多态性和虚函数时应该使用动态联编。动态联编的优点是灵活性强,但效率低。动态联编规定,只能通过指向基类的指针或基类对象的引用来调用虚函数。
    实现动态联编需要同时满足以下三个条件:

    1. 必须把动态联编的行为定义为类的虚函数。
    2. 类之间应满足子类型关系,通常表现为一个类从另一个类公有派生而来。
    3. 必须先使用基类指针指向子类型的对象,然后直接或者间接使用基类指针调用虚函数。

    这时候我们把基类中的声明为虚函数

    class A
    {
    public:
    	virtual void f() { cout << "A" << " "; }
    };
    
    class B :public A
    {
    public:
    	void f() { cout << "B" << endl; }
    };
    
    void main()
    {
    	A *pa;A a; B b;
    
    	pa = &a;
    	pa -> f();
    
    	pa = &b;
    	pa -> f();
    }
    

    如果基类中没有将函数声明为虚函数,pa->f()将根据指针类型调用基类的函数,指针类型在编译时已知。如果将基类中的方法函数声明成虚函数,那么pa->f()根据对象类型调用函数。通常只有在运行程序的时候才能确定对象的类型,所以编译器生成的代码将在程序执行,时根据对象的类型关联,编译器对虚方法使用动态联编。

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

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

    首先,联编是指一个计算机程序的不同部分彼此关联的过程。

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

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

    实现动态联编需要同时满足以下三个条件:
    ①必须把动态联编的行为定义为类的虚函数。
    ②类之间应满足子类型关系,通常表现为一个类从另一个类公有派生而来。
    ③必须先使用基类指针指向子类型的对象,然后直接或者间接使用基类指针调用虚函数。

    展开全文
  • 摘要】:本文阐述了静态联编动态联编的概念和区别,通过具体实例分析了实现动态联编条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编动态联编;虚函数 在C++中,联编是指一个计算机...
  • 按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编动态联编。  1. 静态联编 静态联编是指联编工作在编译阶段完成的,这种联编过程是在程序运行之前完成的,又称为早期联编。要实现静态联编,在...
  • 动态联编和静态联编

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

    千次阅读 2013-06-14 09:44:57
    按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编动态联编。 1. 静态联编 静态联编是指联编工作在编译阶段完成的,这种联编过程是在程序运行之前完成的,又称为早期联编。要实现静态联编,在编译...
  • C++ 虚函数、静态联编动态联编

    千次阅读 2016-01-05 17:12:04
    本文将对c++虚函数做个总结。...纯虚函数在基类中是没有定义的,必须在子类中加以实现,很像java中的接口函数! 虚函数 引入原因:为了方便使用多态特性,我们常常需要在基类中定义虚函数。 class C
  • 联编指的是用于实现和达到多态的一种方式方法. 多态:通过多种形态表现出来. 种类:如函数重载: 通过令传入函数的参数列表中的 参数个数不同, 类型不同, 顺序不同 使得函数名有多种形态来表现 静态多态: 如函数重载和...
  • 本文阐述了静态联编动态联编的概念和区别,通过具体实例分析了实现动态联编条件,指出了虚函数是实现动态联编的基础。在C++中,联编是指一个计算机程序的不同部分彼此关联的过程。按照联编所进行的阶段不同,可...
  • 按照联编所进行的阶段不同,可分为两种不同的联编方法:静态联编动态联编。  1. 静态联编 静态联编是指联编工作在编译阶段完成的,这种联编过程是在程序运行之前完成的,又称为早期联编。要实现静态联编,在编译...
  • 静态联编动态联编

    2019-02-28 23:48:43
    写在前边:转的, 存一下 静态联编动态联编;虚函数 在C++中,联编是指一个计算机程序的不同部分彼此关联的过程。...要实现静态联编,在编译阶段就必须确定程序中的操作调用(如函数调用)与执行该操作代码间...
  • C++虚函数与动态联编

    2019-07-22 22:12:38
    C++虚函数与多态1....静态联编是指在编译阶段就将函数实现和函数调用关联起来,因此静态联编也叫早绑定,在编译阶段就必须了解所有的函数或模块执行所需要检测的信息,它对函数的选择是基于==指向对...
  • C++之静态联编动态联编

    千次阅读 2015-03-14 20:13:40
    按照联编所进行的阶段不同,可分为静态联编动态联编两种。  静态联编  静态联编是指在程序编译连接阶段进行联编。这种联编又称为早期联编,这是因为这种联编工作是在程序运行之前完成的。  编译时所进行的...
  • 静态/动态联编

    2020-07-05 18:58:41
    静态联编 在编译时进行,又称早期联编。编译时规定的地址不可以被后期改变,执行最开始的地址所在类的相应函数。 class dad{ public: double Area(){ return 0.0; } }; class son: public dad{ public: double ...
  • (1)多态性是指相同的函数名对应不同的实现。多态性采用两种方式:重载方式和覆盖方式。重载方式表现在函数重载和运算符重载;覆盖方式表现在基类与派生类中相同说明的函数。(2)函数重载要求被重载的函数应该在...
  • 虚函数与联编

    2019-07-18 18:20:09
    在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数,实现多态性。 语法: virtual 函数返回类型 函数名(参数表) {函数体} 虚函数必须是基类的非静态成员函数,其访问权限可以是private或...
  • 【摘要】:本文阐述了静态联编动态联编的概念和区别,通过具体实例分析了实现动态联编条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编动态联编;虚函数 在C++中,联编是指一个计算机程序的...
  • 摘要】:本文阐述了静态联编动态联编的概念和区别,通过具体实例分析了实现动态联编条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编动态联编;虚函数 在C++中,联编是指一个计算机...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,722
精华内容 5,088
关键字:

动态联编实现的条件