精华内容
下载资源
问答
  • 1、构造一个对象的时候,必须知道对象的实际类型,而虚函数是在运行期间确定实际类型的。如果构造函数为虚函数,则在构造一个对象时,由于对象还未构造成功,编译器还无法知道对象的实际类型,是该类本身还是派生类...

    一、构造函数不能声明为虚函数

    为什么构造函数不能声明为虚函数呢?

    1、构造一个对象的时候,必须知道对象的实际类型,而虚函数是在运行期间确定实际类型的。如果构造函数为虚函数,则在构造一个对象时,由于对象还未构造成功,编译器还无法知道对象的实际类型,是该类本身还是派生类。无法确定。

    2、虚函数的执行依赖于虚函数表,而虚函数表是在构造函数中初始化的,即初始化vptr,让它指向虚函数表。如果构造函数为虚函数,则在构造对象期间,虚函数表还没有被初始化,将无法进行。

    二、析构函数可以声明为虚函数,而且有时是必须声明为虚函数。

    虚析构函数是为了解决这样的一个问题:基类的指针指向派生类对象,并用基类的指针删除派生类对象时,要使用虚析构函数。

    如果某个类不包含虚函数,那一般是表示它将不作为一个基类来使用。当一个类不准备作为基类使用时,使析构函数为虚一般是个坏主意。因为它会为类增加一个虚函数表,使得对象的体积翻倍,还有可能降低其可移植性。

    所以基本的一条是:无故的声明虚析构函数和永远不去声明一样是错误的。实际上,很多人这样总结:当且仅当类里包含至少一个虚函数的时候才去声明虚析构函数。

    抽象类是准备被用做基类的,基类必须要有一个虚析构函数,纯虚函数会产生抽象类,所以方法很简单:在想要成为抽象类的类里声明一个纯虚析构函数。

    只有当一个类被用来作为基类的时候,才把析构函数写成虚函数。

    所以注意如果基类不是虚析构函数的话可能会有以下两点问题:

    1、子类所分配的内存不能被释放
    2、子类中成员变量类所分配的内存也不能被释放,因为子类析构函数没有被调用,其变量的析构函数肯定也没被调用了。

    总之:

    基类指针可以指向派生类的对象(多态性),如果删除该指针delete []p;就会调用该指针指向的派生类析构函数,而派生类的析构函数又自动调用基类的析构函数,这样整个派生类的对象完全被释放。如果析构函数不被声明成虚函数,则编译器实施静态绑定,在删除基类指针时,只会调用基类的析构函数而不调用派生类析构函数,这样就会造成派生类对象析构不完全。所以,将析构函数声明为虚函数是十分必要的。

     

     

     

     

     

    展开全文
  • 1.构造函数为什么不能是虚函数? a.最直观的的一个角度虚函数使得对象内部存在一个指向虚函数表的指针,通过该指针指向的虚函数表确定调用的函数。而在调用构造函数时,对象还没有生成,就根本谈不上虚函数表和...

    1.构造函数为什么不能是虚函数?
    a.最直观的的一个角度是,虚函数使得对象内部存在一个指向虚函数表的指针,通过该指针指向的虚函数表确定调用的函数。而在调用构造函数时,对象还没有生成,就根本谈不上虚函数表和虚函数指针了。

    b.虚函数的调用往往是基于“动态联编”的,即在对象生成之后才能确定调用的是基类中的函数还是派生类中的重写函数。在调用构造函数时,对象还未构造成功,编译器无法知道对象的实际类型,是对象本身,还是派生类对象或者派生类的派生类,自然也无法实现“动态”的调用。

    2.析构函数为什么(某些情况下)必须是虚函数?
    首先明确的是,“某些情况”指的是该类作为基类时,其析构函数必须是虚函数。这是因为,指向基类的指针可以指向派生类对象,如果不声明析构函数为虚函数的话,在一个由基类指针指向的派生类对象析构时,那么只会调用父类的析构函数,自身的析构函数不会被调用,甚至会造成内存泄漏。只有当声明为virtual类型时,才能够先执行派生类自身的析构函数,再执行基类的析构函数,确保执行的顺序正确。

    展开全文
  • 什么是虚函数

    2019-11-20 19:33:27
    什么是虚函数 在某基类中生命为virtual并在一个或多个派生类中被重新定义成员函数,用法格式为: virtual函数返回类型 函数名(参数列表){函数体} 实现多态性,通过指向派生类基类指针或引用,访问派生类中...

    什么是虚函数

    在某基类中生命为virtual并在一个或多个派生类中被重新定义的成员函数,用法格式为:

    virtual函数返回类型 函数名(参数列表){函数体}
    

    实现多态性,通过指向派生类的基类指针或引用,访问派生类中的同名覆盖函数。

    虚函数的创建继承

    虚函数继承是解决多态性的,当用基类指针指向派生类对象的时候,基类指针调用虚函数的时候会自动调用派生类的虚函数,这就是多态性,也叫动态编联。
    演示,先看下面代码:

    #include<iostream>
    using namespace std;
    class A
    {
        public:
            void print()
            {
                cout<<"This is A"<<endl;
            }
    };
     
    class B : public A
    {
        public:
            void print()
            {
                cout<<"This is B"<<endl;
            }
    };
     
    int main()
    {
        //为了在以后便于区分,我这段main()代码叫做main1
        A a;
        B b;
        a.print();
        b.print();
        return 0;
    }
    

    输出结果是:
    This is A
    This is B
    上面通过调用不同类的print实现了不同的策略,不过这不是多态,这是不同类型指针持续的结果而已,我们改一下main函数:

    int main()
    {
        //main2
        A a;
        B b;
        A *p1 = &a;
        A *p2 = &b;
        p1->print();
        p2->print();
        return 0;
    }
    

    输出结果为:
    This is A
    This is A
    这明显不是我们需要的结果,而如果我们采用虚函数,将类改动一下,如下:

    class A
    {
        public:
            virtual void print()
            {
                cout<<"This is A"<<endl;
            }
    };
     
    class B : public A
    {
        public:
            void print()
            {
                cout<<"This is B"<<endl;
            }
    };
    

    这个时候输出就是:
    This is A
    This is B
    这就是多态。

    正确理解函数的重载、覆盖、隐藏

    上面三种都是对应同名函数的三种关系:
    重载:函数名相同,作用域不同,函数参数不同。
    覆盖:基类和派生类中的函数同名,同参数,基类中的函数是虚函数,派生类中的同名函数会覆盖基类中的同名同参的虚函数。
    隐藏:派生类中的函数会隐藏基类的函数。

    虚函数是如何访问的

    我们这里就用上面的类A和B来做解释,首先上面两个类里面都有虚函数,当编译器发现两个类中有虚函数存在的时候,就会为他们分别插入一段数据,并且分别为他们见一个表,那段数据叫做vptr指针,指向的表叫做vtbl,vtbl的作用就是保存自己类中虚函数的地址,可以看成是一个数组,这个数据的每一个元素存放的就是虚函数的地址。
    然后我们创建一个A类的指针,然后去调用print函数,这个时候肯定调用的是A::print函数,这操作首先是取出类里面的vptr的值,这个值就是vtbl的地址,在根据这个值找到vtbl,这个时候vtbl里面只有A::print的地址,所以直接就是调用A::print函数
    如果我们指向B类型的指针,这个时候vtbl里面保存的就是有A和B的print函数,但是B类里面的vptr里面指向的地址是B::print而不是A::print,这是时候就会访问B::print函数

    参考资料:
    https://baike.baidu.com/item/%E8%99%9A%E5%87%BD%E6%95%B0/2912832
    https://blog.csdn.net/n1314n/article/details/90712962

    展开全文
  • 什么是C++虚函数虚函数的作用和使用方法 我们知道,在同一类中不能定义两个名字相同、参数个数和类型都相同的函数的,否则就是“重复定义”。但是在类的继承层次结构中,在不同的层次中可以出现名字相同、参数个...

    什么是C++虚函数、虚函数的作用和使用方法

    我们知道,在同一类中是不能定义两个名字相同、参数个数和类型都相同的函数的,否则就是“重复定义”。但是在类的继承层次结构中,在不同的层次中可以出现名字相同、参数个数和类型都相同而功能不同的函数。例如在例12.1(具体代码请查看:C++多态性的一个典型例子)程序中,在Circle类中定义了 area函数,在Circle类的派生类Cylinder中也定义了一个area函数。这两个函数不仅名字相同,而且参数个数相同(均为0),但功能不同,函数体是不同的。前者的作用是求圆面积,后者的作用是求圆柱体的表面积。这是合法的,因为它们不在同一个类中。 编译系统按照同名覆盖的原则决定调用的对象。在例12.1程序中用cy1.area( ) 调用的是派生类Cylinder中的成员函数area。如果想调用cy1 中的直接基类Circle的area函数,应当表示为 cy1.Circle::area()。用这种方法来区分两个同名的函数。但是这样做 很不方便。

    人们提出这样的设想,能否用同一个调用形式,既能调用派生类又能调用基类的同名函数。在程序中不是通过不同的对象名去调用不同派生层次中的同名函数,而是通过指针调用它们。例如,用同一个语句“pt->display( );”可以调用不同派生层次中的display函数,只需在调用前给指针变量 pt 赋以不同的值(使之指向不同的类对象)即可。

    打个比方,你要去某一地方办事,如果乘坐公交车,必须事先确定目的地,然后乘坐能够到达目的地的公交车线路。如果改为乘出租车,就简单多了,不必查行车路线,因为出租车什么地方都能去,只要在上车后临时告诉司机要到哪里即可。如果想访问多个目的地,只要在到达一个目的地后再告诉司机下一个目的地即可,显然,“打的”要比乘公交车 方便。无论到什么地方去都可以乘同—辆出租车。这就是通过同一种形式能达到不同目的的例子。

    C++中的虚函数就是用来解决这个问题的。虚函数的作用是允许在派生类中重新定义与基类同名的函数,并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

    请分析例12.2。这个例子开始时没有使用虚函数,然后再讨论使用虚函数的情况。

    [例12.2] 基类与派生类中有同名函数。在下面的程序中Student是基类,Graduate是派生类,它们都有display这个同名的函数。
    #include
    #include
    using namespace std;
    //声明基类Student
    class Student
    {
    public:
    Student(int, string,float); //声明构造函数
    void display( );//声明输出函数
    protected: //受保护成员,派生类可以访问
    int num;
    string name;
    float score;
    };
    //Student类成员函数的实现
    Student::Student(int n, string nam,float s)//定义构造函数
    {
    num=n;
    name=nam;
    score=s;
    }
    void Student::display( )//定义输出函数
    {
    cout<<“num:”<<num<<"\nname:"<<name<<"\nscore:"<<score<<"\n\n";
    }
    //声明公用派生类Graduate
    class Graduate:public Student
    {
    public:
    Graduate(int, string, float, float);//声明构造函数
    void display( );//声明输出函数
    private:float pay;
    };
    // Graduate类成员函数的实现
    void Graduate::display( )//定义输出函数
    {
    cout<<“num:”<<num<<"\nname:"<<name<<"\nscore:"<<score<<"\npay="<<pay<<endl;
    }
    Graduate::Graduate(int n, string nam,float s,float p):Student(n,nam,s),pay§{}
    //主函数
    int main()
    {
    Student stud1(1001,“Li”,87.5);//定义Student类对象stud1
    Graduate grad1(2001,“Wang”,98.5,563.5);//定义Graduate类对象grad1
    Student *pt=&stud1;//定义指向基类对象的指针变量pt
    pt->display( );
    pt=&grad1;
    pt->display( );
    return 0;
    }
    运行结果如下:
    num:1001(stud1的数据)
    name:Li
    score:87.5

    num:2001 (grad1中基类部分的数据)
    name:wang
    score:98.5

    假如想输出grad1的全部数据成员,当然也可以采用这样的方法:通过对象名调用display函数,如grad1.display(),或者定义一个指向Graduate类对象的指针变量ptr,然后使ptr指向gradl,再用ptr->display()调用。这当然是可以的,但是如果该基类有多个派生类,每个派生类又产生新的派生类,形成了同一基类的类族。每个派生类都有同名函数display,在程序中要调用同一类族中不同类的同名函数,就要定义多个指向各派生类的指针变量。这两种办法都不方便,它要求在调用不同派生类的同名函数时采用不同的调用方式,正如同前面所说的那样,到不同的目的地要乘坐指定的不同的公交车,一一 对应,不能搞错。如果能够用同一种方式去调用同一类族中不同类的所有的同名函数,那就好了。

    用虚函数就能顺利地解决这个问题。下面对程序作一点修改,在Student类中声明display函数时,在最左面加一个关键字virtual,即
    virtual void display( );
    这样就把Student类的display函数声明为虚函数。程序其他部分都不改动。再编译和运行程序,请注意分析运行结果:
    num:1001(stud1的数据)
    name:Li
    score:87.5

    num:2001 (grad1中基类部分的数据)
    name:wang
    score:98.5
    pay=1200 (这一项以前是没有的)

    看!这就是虚函数的奇妙作用。现在用同一个指针变量(指向基类对象的指针变量),不但输出了学生stud1的全部数据,而且还输出了研究生grad1的全部数据,说明已调用了grad1的display函数。用同一种调用形式“pt->display()”,而且pt是同一个基类指针,可以调用同一类族中不同类的虚函数。这就是多态性,对同一消息,不同对象有 不同的响应方式。

    说明:本来基类指针是用来指向基类对象的,如果用它指向派生类对象,则进行指针类型转换,将派生类对象的指针先转换为基类的指针,所以基类指针指向的是派生类对象中的基类部分。在程序修改前,是无法通过基类指针去调用派生类对象中的成员函数的。虚函数突破了这一限制,在派生类的基类部分中,派生类的虚函数取代了基类原来的虚函数,因此在使基类指针指向派生类对象后,调用虚函数时就调用了派生类的虚函数。 要注意的是,只有用virtual声明了虚函数后才具有以上作用。如果不声明为虚函数,企图通过基类指针调用派生类的非虚函数是不行的。

    虚函数的以上功能是很有实用意义的。在面向对象的程序设计中,经常会用到类的继承,目的是保留基类的特性,以减少新类开发的时间。但是,从基类继承来的某些成员函数不完全适应派生类的需要,例如在例12.2中,基类的display函数只输出基类的数据,而派生类的display函数需要输出派生类的数据。过去我们曾经使派生类的输出函数与基类的输出函数不同名(如display和display1),但如果派生的层次多,就要起许多不同的函数名,很不方便。如果采用同名函数,又会发生同名覆盖。

    利用虚函数就很好地解决了这个问题。可以看到:当把基类的某个成员函数声明为虚函数后,允许在其派生类中对该函数重新定义,赋予它新的功能,并且可以通过指向基类的指针指向同一类族中不同类的对象,从而调用其中的同名函数。由虚函数实现的动态多态性就是:同一类族中不同类的对象,对同一函数调用作出不同的响应。

    虚函数的使用方法是:
    在基类用virtual声明成员函数为虚函数。
    这样就可以在派生类中重新定义此函数,为它赋予新的功能,并能方便地被调用。在类外定义虚函数时,不必再加virtual。
    在派生类中重新定义此函数,要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同,并根据派生类的需要重新定义函数体。
    C++规定,当一个成员函数被声明为虚函数后,其派生类中的同名函数都自动成为虚函数。因此在派生类重新声明该虚函数时,可以加virtual,也可以不加,但习惯上一般在每一层声明该函数时都加virtual,使程序更加清晰。如果在派生类中没有对基类的虚函数重新定义,则派生类简单地继承其直接基类的虚函数。
    定义一个指向基类对象的指针变量,并使它指向同一类族中需要调用该函数的对象。
    通过该指针变量调用此虚函数,此时调用的就是指针变量指向的对象的同名函数。
    通过虚函数与指向基类对象的指针变量的配合使用,就能方便地调用同一类族中不同类的同名函数,只要先用基类指针指向即可。如果指针不断地指向同一类族中不同类的对象,就能不断地调用这些对象中的同名函数。这就如同前面说的,不断地告诉出租车司机要去的目的地,然后司机把你送到你要去的地方。

    需要说明;有时在基类中定义的非虚函数会在派生类中被重新定义(如例12.1中的area函数),如果用基类指针调用该成员函数,则系统会调用对象中基类部分的成员函数;如果用派生类指针调用该成员函数,则系统会调用派生类对象中的成员函数,这并不是多态性行为(使用的是不同类型的指针),没有用到虚函数的功能。

    以前介绍的函数重载处理的是同一层次上的同名函数问题,而虚函数处理的是不同派生层次上的同名函数问题,前者是横向重载,后者可以理解为纵向重载。但与重载不同的是:同一类族的虚函数的首部是相同的,而函数重载时函数的首部是不同的(参数个数或类型不同)。

    展开全文
  • 1)因为创建一个对象时需要确定对象的类型,而虚函数是在运行时确定其类型的。而在构造一个对象时,由于对象还未创建成功,编译器无法知道对象的实际类型,是类本身还是类的派生类等等 2)虚函数的调用需要虚函数表...
  • 虚函数的默认参数的值是依赖对象静态类型决定的 我们来先从一道题来引出这个问题: 这道题的要求是输出结果是什么?...就是说,虚函数的默认参数取的是静态类型的。 那么什么是静态类型呢?举个栗子
  • 构造一个对象时,必须知道对象实际类型,而虚函数是在运行期间确定实际类型的。而在构造一个对象时,由于对象还未构造成功,编译器就无法知道对象的实际类型,是该类本身,还是派生类,还是其他。 虚函数的执行依赖...
  • 1.调用虚函数需要访问虚表,构造函数在调用前根本不存在虚表,这带来了先有鸡还是先有蛋问题; ...3.构造函数是定义一个对象时自动调用,用户不能自己调用构造函数,所以没必要是虚函数; ...
  • 目录 虚函数实质——虚函数表 ...这里除了父类Base中仅成员函数Func2没被声明为虚函数是从基类中继承过来其他成员函数全部将父类同名成员函数替换。 虚函数表中存着每个成员函数真实地..
  • 虚构函数是虚函数的情况只需要在特定场景下出现即可,正常情况下不必要弄成虚函数。 如果基类析构函数不是虚函数,在特定情况下会导致派生来无法被析构。 情况1:用派生类类型指针绑定派生类实例,析构时候,...
  • 简要结论: 1. 从语法上讲,调用完全没有问题。 2. 但是从效果上看,往往不...所以,虚函数始终仅仅调用基类的虚函数(如果基类调用虚函数),不能达到多态效果,所以放在构造函数中没有意义,而且往往不...
  • 1 构造一个对象的时候,必须知道对象的实际类型,而虚函数行为在运行期间确定实际类型的。而在构造一个对象时,由于对象还未构造成功。编译器无法知道对象 的实际类型,该类本身,还是该类的一个派生类,或是更...
  • 1. 构造函数为什么不能为虚函数? a. 存储空间角度: 虚函数的调用需要虚函数表指针,而该指针存放在对象内容空间中,需要调用构造...虚函数主要实现多态,在运行时才可以明确调用对象,根据传入对象类型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,001
精华内容 400
关键字:

虚函数是什么类型的函数