精华内容
下载资源
问答
  • 本文阐述了静态联编和动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。
  • 动态联编与静态联编区别

    千次阅读 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

    展开全文
  • 本文阐述了静态联编和动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。在C++中,联编是指一个计算机程序的不同部分彼此关联的过程。按照联编所进行的阶段不同,可...

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

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

    1.静态联编

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

    例1 :静态联编

    #include"iostream"
    using namespace std;
    
    class A
    {
    public:
        voidf(){cout<<"A"<<"";}
    };
    
    classB:publicA
    {
    public:
        voidf(){cout<<"B"<<endl;}
    };
    
    Void main()
    {
        A *pa=NULL;
        A a;
        B b;
        pa=&a;
        pa->f();
        pa=&b;
        pa->f();
    
    }

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

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

    2 动态联编

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

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

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

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

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

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

    例 2 动态联编

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

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

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

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

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

    #include <iostream>
    using namespace std;
    
    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(int x){
    		cout<<"derived fun2"<<endl;
    	}
    	
    	virtual void fun3(){
    		cout<<"derived fun3"<<endl;
    	}
    	
    	void fun4(){
    		cout<<"derived fun4"<<endl;
    	}
    };
    
    int main()
    
    {
    	base *pb;
    	derived d;
    	pb=&d;   //通过指向基类的指针来调用虚函数
    	pb->fun1();
    	pb->fun2();
    	pb->fun3();
    	pb->fun4();
    	return 0;
    }

    输出结果为:

    Derived fun1

    base fun2

    base fun3

    base fun4

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

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

    #include <iostream>
    using namespace std;
    
    class CPoint
    {
    public:
    	CPoint(double i,double j){
    		x=i;
    		y=j;
    	}
    
    	virtual double Area(){
    		return 0;
    	}
    	
    private:	
    	double x,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; 
     }//通过基类对象的引用来调用虚函数
    
    
    int  main()
    {	
    	CRectangle rec(3, 5.2, 15, 25);	
    	fun(rec);	
    	return 0;
    }

    该程序的运行结果为:375

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









    展开全文
  • 【摘要】:本文阐述了静态联编和动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编;动态联编;虚函数 在C++中,联编是指一个计算机程序...

    http://blog.163.com/hi_qiqiy@126/blog/static/144066791201011221177823/

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

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

    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 idouble jdouble kdouble l);

    Double Area(){return w*h;}

    private:

    double w,h

    };

    CRectangle::CRectangle(double idouble jdouble kdouble 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*25375。这是因为一个虚函数无论被公有继承多少次,它仍然保持其虚特性。在派生类中重新定义虚函数时,关键字virtual可以写也可不写,但为了保持良好的编程风格,避免引起混乱时,应写上该关键字。

    4. 小结

        从以上四个例子中可以看出:虚函数是实现多态的基础,是实现动态联编的必要条件之一。动态联编要靠虚函数来实现,虚函数要靠动态联编的支持。两者相辅相成,缺一不可。
    展开全文
  • 摘要】:本文阐述了静态联编和动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编;动态联编;虚函数 在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 idouble jdouble kdouble l);

    Double Area(){return w*h;}

    private:

    double w,h

    };

    CRectangle::CRectangle(double idouble jdouble kdouble 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*25375。这是因为一个虚函数无论被公有继承多少次,它仍然保持其虚特性。在派生类中重新定义虚函数时,关键字virtual可以写也可不写,但为了保持良好的编程风格,避免引起混乱时,应写上该关键字。

    4. 小结

        从以上四个例子中可以看出:虚函数是实现多态的基础,是实现动态联编的必要条件之一。动态联编要靠虚函数来实现,虚函数要靠动态联编的支持。两者相辅相成,缺一不可。
    展开全文
  • 摘要】:本文阐述了静态联编和动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编;动态联编;虚函数 在C++中,联编是指一个计算机...
  • 【摘要】:本文阐述了静态联编和动态联编的概念和区别,通过具体实例分析了实现动态联编的条件,指出了虚函数是实现动态联编的基础。 【关键词】:静态联编;动态联编;虚函数 在C++中,联编是指一个计算机程序的...
  • 动态联编多态性(运行时的多态性)通过继承,虚函数(当运行时才能实现对象与函数的联编)C++规定:动态联编是在虚函数的支持下实现的 条件:指向派生类对象的基类指针或者引用派生类对象的基类引用(调用虚函数...
  • 条件 所以,实现动态联编需要三个条件: 1、 必须把动态联编的行为定义为类虚函数。 2、 类之间存在子类型关系,一般表现为一个类从另一个类公有派生而来。 3、 必须先使用基类指针指向子类型...
  • C++学习笔记-多态的实现原理

    千次阅读 2019-04-03 21:01:09
    深入了解多态的实现原理,有助于提高对于多态的认识 多态基础 多态的实现效果 多态:同样的调用语句有多种不同的表现形态 多态实现的三个条件 有继承、有virtual重写、有父类...动态联编PK静态联编。根据实际的对...
  • 1-多态 多态的实现效果:多态实现了同样调用语句具有不同表现形态。 多态成立三个条件:继承、徐函数重写、... 多态理论基础:动态联编(if、switch、多态)、静态联编、根据指针实际指向对象类型来判...
  • C++网络作业答案.docx

    2020-09-29 14:15:43
    作业4 选择题 1.下列关于动态联编的描述中错误是 A动态联编是...注释动态联编一直要到程序运行时才能确定调用哪个函数 虚函数是实现动态联编的必要条件之一没有虚函数一定不能实现动态联编但 有虚函数存在时必须同时
  • c++网络作业6答案.pdf

    2020-05-13 06:17:37
    作业 4 一 选择题 1 下列关于动态联编的...注先期联编也称静态联编迟后联编也称动态联编 注释动态联编一直要到程序运行时才能确定调用哪个函数 虚函数是实现动态联编的必要条件之一没有虚函数一定不能实现动态联编但 有
  • 1、 多态基础 (1)多态的实现效果  多态:同样的调用语句有多种不同的表现形态; (2)多态实现的三个条件  有继承、有virtual重写、有父类指针(引用)指向子类对象。... 动态联编PK静态联编。
  • 1、 多态基础 多态的实现效果 ...多态:同样的调用语句有多种不同的表现形态;...多态实现的三个条件  ...有继承、有virtual重写、有父类指针(引用)指向子类对象。... 动态联编PK静态联编。根据
  • 1、 多态基础 多态的实现效果 多态:同样的调用语句有多种不同的表现形态; 多态实现的三个条件  有继承、有virtual重写、有父类指针(引用)指向子类对象。 多态的C++实现 ... 动态联编PK静态联编
  • C++中类多态基础

    2019-09-06 16:44:18
    多态成立三个条件: 要有继承。 要有虚函数重写。... 动态联编:程序链接在程序运行时进行,又称为迟绑定。switch和if语句就是动态联编,C++中类指针多态也是。 C与C++编译: C与C++都是...
  • 虚函数机制

    2014-01-04 20:04:00
    虚函数为了实现动态联编(运行多态)而引入概念。 动态联编(dynamic binding)和静态联编(static binding)。静态联编意味着编译器能够直接将标识符和存储物理地址联系在一起。每一个函数都有一个唯一物理...
  • 对于多态理解

    2019-08-10 13:29:03
    多态的实现效果 多态:同样的调用语句有多种不同的表现形态 多态实现的三个条件 有继承。有virtual重写。...动态联编pk静态联编,根据实际的对象类型来判断重写函数的调用 多态的重要意义 设计模式的...
  • c++中多态机制

    2020-05-27 15:21:05
     2-4静态联编和动态联编  2-5动态多态的实现原理  2-6 虚析构函数  2.7关于虚函数思考题  2.8纯虚函数、抽象类、接口 背景介绍  虚函数重写:子类重新定义父类中有相同返回值、名称和参数虚函数;  非虚...

空空如也

空空如也

1 2 3 4 5
收藏数 96
精华内容 38
关键字:

动态联编实现的条件