精华内容
下载资源
问答
  • C++ 虚析构函数

    2018-08-15 21:58:59
    �� 在析构函数前面加上关键字virtual进行声明,称该析构函数为虚析构函数 �� 构造函数不能是虚函数 �� 如果一个基类的析构被声明为虚析构函数,则它的派生类中的析构函数也是虚函数 �� 声明虚析构函数的...

    ? 在析构函数前面加上关键字virtual进行声明,称该析构函数为虚析构函数
    ? 构造函数不能是虚函数
    ? 如果一个基类的析构被声明为虚析构函数,则它的派生类中的析构函数也是虚函数
    ? 声明虚析构函数的目的在于使用delete运算符删除一个对象时,能确保析构函数被正确的执行。因为设置虚析构函数后,可以采用动态连编的方式选择析构函数

    //虚析构函数 
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class ClxBase{
    public:
        ClxBase(){
            cout<<"construct Base class!"<<endl;
        }
    
       virtual ~ClxBase(){
            cout<<"in destructor of class ClxBase"<<endl;
        }
    
        void DoSomething(){
            cout << "!!!!Do something in class ClxBase!!!" << endl; 
        }
    };
    
    
    class ClxDerived : public ClxBase{
    public:
        ClxDerived(){
            cout<<"construct Sub class!"<<endl;
        }
    
        ~ClxDerived(){
            cout << "in destructor of class ClxDerived!" << endl; 
        } 
    
        void DoSomething(){ 
            cout << "====Do something in class ClxDerived!====" << endl; 
        }
    };
    
    
    int main()
    {
        ClxBase *pTest = new ClxDerived;
        pTest->DoSomething();
        delete pTest;
        cout<<"\nafter delete"<<endl;
    
        //ClxDerived aa;
        return 0;
    }
    展开全文
  • C++虚析构函数

    2020-06-14 11:29:41
    1、虚析构函数的作用:避免内存泄漏。 使用虚析构函数在删除指向子类对象的基类指针时,可以调用子类的析构函数使子类占用的堆内存释放,从而防止内存泄漏。 2、使用总结 (1)在基类的析构函数前加上virtual...

    1、虚析构函数的作用:避免内存泄漏。

    使用虚析构函数在删除指向子类对象的基类指针时,可以调用子类的析构函数使子类占用的堆内存释放,从而防止内存泄漏。

    2、使用总结

    (1)在基类的析构函数前加上virtual关键字,那么就是虚析构函数。

    (2)当基类中的析构函数声明为虚析构函数时,派生类开始从基类继承。

    (3)基类的指针指向派生类的对象时,delete基类的指针时,先调用派生类的析构函数,再调用基类中的析构函数。

    #include <iostream>
    using namespace std;
    
    ///基类
    class Base{
        public:
            Base(){};
            virtual ~Base(){  //1、定义虚析构函数
                cout << "delete Base\n";
            };
            virtual void DoSomething(){
                cout << "Do Something in class Base!\n";
            };
    };
    
    ///派生类
    class Derived: public Base{ //2、子类继承
        public:
            Derived(){};
            ~Derived(){
                cout << "delete Derived\n";
            };
            void DoSomething(){
                cout << "Do Something in Derived\n";
            };
    };
    
    
    int main(){
        Base *b = new Derived;  //3、基类指针指向子类
        b->DoSomething();
        delete b;
        return 0;
    }
    
    

     

    展开全文
  •  虚析构函数  析构函数的工作方式是:底层的派生类(most derived class)的析构函数先被调用,然后调用每一个基类的析构函数。  因为在C++中,当一个派生类对象通过使用一个基类指针删除,而这个基类有一个非...
  • 本篇文章是对C++虚析构函数的使用进行了详细的分析介绍,需要的朋友参考下
  • 1、为什么要使用虚析构函数 我们知道析构函数是在对象生命周期结束时自动被调用,用来做一些清理工作(如释放句柄,释放堆内存等),防止出现内存泄漏。 那怎么还有虚析构函数呢? 使用虚析构函数的类一般是要...

    1、为什么要使用虚析构函数

    我们知道析构函数是在对象生命周期结束时自动被调用,用来做一些清理工作(如释放句柄,释放堆内存等),防止出现内存泄漏。

    那怎么还有虚析构函数呢?

    使用虚析构函数的类一般是要作为基类,被其他类继承。通过把基类的析构函数声明为虚函数,就可以通过父类指针来释放子类对象,从而完成子类的一些清理工作,防止出现内存泄漏。

    案例1:基类析构函数为非虚函数

    //test.h
    class Parent
    {
    public:
            Parent();
            ~Parent();
    private:
            int *p_ptr;
    };
    
    class Child : public Parent
    {
    public:
            Child();
            ~Child();
    private:
            int *c_ptr;
    };
    
    //test.cpp
    #include "test.h"
    #include <iostream>
    
    using namespace std;
    
    Parent::Parent()
    {
            p_ptr=new int;
            *p_ptr=10;
    }
    
    Parent::~Parent()
    {
            cout << "Parent::~Parent() was called." << endl;
            if(p_ptr != 0)
            {
                    delete p_ptr;
                    p_ptr=0;
            }
    }
    
    Child::Child()
    {
            c_ptr=new int;
            *c_ptr=20;
    }
    
    //main.cpp
    #include "test.h"
    
    void func(Parent *parent)
    {
            delete parent;//通过父类指针来释放子类对象
    }
    
    int main(int argc, char *argv[])
    {
            Child *child=new Child;
    
            func(child);
            return 1;
    }
    

    运行结果:

    Parent::~Parent() was called.
    结论:父类析构函数为非虚函数时,通过父类指针来释放子类对象时,只会调用父类的析构函数,而不会调用子类的析构函数,造成了子类的内存泄漏。所以,应该将父类的析构函数声明为虚函数。

    案例2:父类的析构函数为虚函数

    其他文件不用动,只需修改test.h,将父类的析构函数声明为虚函数。

    //test.h
    class Parent
    {
    public:
            Parent();
            virtual ~Parent();//虚析构函数
    private:
            int *p_ptr;
    };
    
    class Child : public Parent
    {
    public:
            Child();
            ~Child();
    private:
            int *c_ptr;
    };
    
    

    运行结果:

    Child::~Child() was called.
    Parent::~Parent() was called.
    结论:只有将父类的析构函数声明为虚析构函数时,通过父类指针释放子类对象时,会先调用子类的析构函数,然后调用父类的析构函数,不存在内存泄漏问题。

    2、纯虚析构函数

    通过上面的虚析构函数知道,C++基类的析构函数最好声明为虚机构函数,那什么时候声明为纯虚析构函数呢?

    我们知道,带有纯虚函数的类为抽象类,不能被实例化,只能被子类继承,所以当我们设计一个基类为抽象类时,可以把析构函数声明为纯虚析构函数,这样基类就是抽象类了。

    注意:纯虚析构函数也要有函数体,用来做一些基类的清理工作,防止基类出现内存泄漏。

    展开全文
  • c++ 虚析构函数

    2012-07-19 10:28:39
    c++必须使用虚析构函数的要点: 1.该类分配了资源,而这些资源又不会由成员函数自动释放; 2.通常在构造函数中包含new操作,析构函数中包含delete操作; 3.虚析构函数只有在该类为基类的情况下才有用,即该类被...

    c++必须使用虚析构函数的要点:

    1.该类分配了资源,而这些资源又不会由成员函数自动释放

    2.通常在构造函数中包含new操作,析构函数中包含delete操作;

    3.虚析构函数只有在该类为基类的情况下才有用,即该类被继承的情况;



    下面的示例显示了,当基类base的析构函数为虚析构函数和非虚析构函数的情况下,析构函数的调用情况:


    头文件1:

    class base
    {
    public:
    	base(void);
    	~base(void);
    };
    
    class derive : public base
    {
    public:
    	derive(void);
    	~derive(void);
    };
    

    头文件2:

    class base
    {
    public:
    	base(void);
    	virtual ~base(void);
    };
    
    class derive : public base
    {
    public:
    	derive(void);
    	~derive(void);
    };
    


    源文件:

    base::base(void)
    {
    	printf("base constructor ...\n");
    }
    
    base::~base(void)
    {
    	printf("base destructor ...\n");
    }
    
    derive::derive(void)
    {
    	printf("derive constructor ...\n");
    }
    
    derive::~derive(void)
    {
    	printf("derive destructor ...\n");
    }
    

    调用情况:

    	base *p = new derive;
    	delete p;



    输出情况:

    析构函数为非虚函数的情况:

    base constructor ...
    derive constructor ...
    base destructor ...


    析构函数为非虚函数的情况:

    base constructor ...
    derive constructor ...
    derive destructor ...
    base destructor ...



    展开全文
  • C++虚析构函数与纯虚析构函数

    千次阅读 2013-07-28 20:24:07
    C++虚析构函数与纯虚析构函数 虚析构函数 析构函数的工作方式是:最底层的派生类(most derived class)的析构函数最先被调用,然后调用每一个基类的析构函数。 因为在C++中,当一个派生类对象通过使用一...
  • c++ virtual 虚析构函数及虚函数的详细例子.rar
  • C++虚析构函数及纯虚析构函数

    千次阅读 2016-09-14 23:40:49
    C++析构函数可以为纯虚吗? 众所周知,在实现多态的过程中,一般将基类的析构函数设为virtual,以便在delete的时候能够多态的链式调用。那么析构函数是否可以设为纯虚呢? class CBase { public: CBase() { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,704
精华内容 17,081
关键字:

c++虚析构函数

c++ 订阅