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

    2016-03-18 16:10:45
    将基类的析构函数定义为函数,避免程序退出在销毁资源时只对子类的析构函数进行了调用,而没有对 基类的析构函数进行调用,从而引起漏掉资源的释放

    将基类的析构函数定义为虚函数,避免程序退出在销毁资源时只对子类的析构函数进行了调用,而没有对

    基类的析构函数进行调用,从而引起漏掉资源的释放

    展开全文
  • C++ 虚析构函数作用

    2020-02-04 11:46:47
    类的析构函数作用 类的析构函数是为了释放内存资源,析构函数不被调用的话就会造成内存泄漏。 虚析构函数 定义为虚析构函数是为了当用一个基类的指针删除一个派生类的对象时,派生类的析构函数会被调用。 但并不是...

    类的析构函数作用

    类的析构函数是为了释放内存资源,析构函数不被调用的话就会造成内存泄漏。

    虚析构函数

    定义为虚析构函数是为了当用一个基类的指针删除一个派生类的对象时,派生类的析构函数会被调用。
    但并不是要把所有类的析构函数都写成虚函数。只有当一个类被用来作为基类的时候,才把析构函数写成虚函数。

    示例代码:

    class Base
    {
    public:
        Base(string data) : m_data(data){ }
        ~Base(){ cout << "Base:: ~Base" << endl; }
        void show(){ cout << m_data << endl; }
        string GetData(){ return m_data; }
    private:
        string m_data;
    };
    
    class Demo : public Base
    {
    public:
        Demo(int id, string data) : m_id(id), Base(data){ }
        ~Demo(){ cout << "Demo::~Demo" << endl; }
        void display(){ cout << m_id << "  " << GetData() << endl; }
    private:
        int m_id;
    };
    
    int main()
    {
        Demo* DDemo = new Demo(1, "hello"); //子类指针指向子类
        cout << "delete 子类指针"<< endl;
        delete DDemo;
    
        Base* BBase = new Demo(2, "zhou");  //父类指针指向子类
        cout << "delete 父类指针" << endl;
        delete BBase;
    

    这里写图片描述
    从运行结果中可以的到:
    - 当子类指针指向子类时,析构函数会先调用子类析构在调用父类析构,释放所有内存。
    - 但父类指针指向子类时,只会调用父类析构函数,子类析构函数不被调用,会造成内存泄漏。
    所以我们才需要虚析构函数,将父类的析构函数定义为虚析构函数,那么父类指针会先调用子类析构,在调用父类析构,是内存得到释放。

    class Base
    {
    public:
        Base(string data) : m_data(data){ }
        virtual ~Base(){ cout << "Base:: ~Base" << endl; }
        void show(){ cout << m_data << endl; }
        string GetData(){ return m_data; }
    private:
        string m_data;
    };
    
    class Demo : public Base
    {
    public:
        Demo(int id, string data) : m_id(id), Base(data){ }
        ~Demo(){ cout << "Demo::~Demo" << endl; }
        void display(){ cout << m_id << "  " << GetData() << endl; }
    private:
        int m_id;
    };
    
    int main()
    {
        Demo* DDemo = new Demo(1, "hello");
        cout << "delete 子类指针"<< endl;
        delete DDemo;
    
        Base* BBase = new Demo(2, "zhou");
        cout << "delete 父类指针" << endl;
        delete BBase;
    
        system("pause");
        return 0;
    }
    

    这里写图片描述
    从运行结构可以看出:
    - 将父类定义为虚析构函数后,当定义一直父类指针指向子类时,在delete时可以调用子类和父类的析构函数,释放所有的内存,防止内存泄漏。

    展开全文
  • 虚析构函数作用示例

    2011-10-13 00:15:06
    关于虚析构函数作用示例. 首先是一个main方法驱动头文件如下: [code="c++"] #include "TestVirtualDestructor.h" int main() { Person *person = new Student; delete person; ...
    关于虚析构函数作用示例.
    
    首先是一个main方法驱动头文件如下:

    #include "TestVirtualDestructor.h"

    int main() {

    Person *person = new Student;
    delete person;

    return 0;
    }
    /**
    * 输出结果:
    *
    *1.没有使用虚析构函数的时候的输出:子类的析构函数没有调用.
    调用Person的构造函数.
    调用Student的构造函数.
    调用Person的析构函数.
    */


    相关的类文件如下:

    /*
    * TestVirtualDestructor.h
    *
    * Created on: 2011-10-12
    * Author: banxi1988
    */
    #include "common.h"

    class Person{
    public:
    Person(){
    cout<<"调用Person的构造函数."<<endl;
    };
    ~Person(){
    cout<<"调用Person的析构函数."<<endl;
    }
    };
    class Student:public Person{
    public:
    Student(){
    ptr = new int;
    cout<<"调用Student的构造函数."<<endl;
    }
    ~Student(){
    delete ptr;
    cout<<"调用Student的析构函数."<<endl;

    }
    private:
    int *ptr;
    };


    这个时候的输出结果,可以很明显的看出没有调用子类的析构函数.
    而在子类也而在删除person实例时,其实需要释放它在堆上生成的一个ptr.
    .

    我们将~Person声明为virtual ~Person之后运行结果如下:

    /**
    *
    调用Person的构造函数.
    调用Student的构造函数.
    调用Student的析构函数.
    调用Person的析构函数.

    */


    所以析构函数,还是用虚的总是好的.
    所以代码重构如下:

    /*
    * TestVirtualDestructor.h
    *
    * Created on: 2011-10-12
    * Author: banxi1988
    */
    #include "common.h"

    class Person{
    public:
    Person(){
    cout<<"调用Person的构造函数."<<endl;
    };
    virtual ~Person(){
    cout<<"调用Person的析构函数."<<endl;
    }
    };
    class Student:public Person{
    public:
    Student(){
    ptr = new int;
    cout<<"调用Student的构造函数."<<endl;
    }
    virtual ~Student(){
    delete ptr;
    cout<<"调用Student的析构函数."<<endl;

    }
    private:
    int *ptr;
    };

    展开全文
  • 在没有虚析构函数的情况下

    1.在没有虚析构函数的情况下

    #pragma once
    
    class CPointX
    {
    public:
    	CPointX(void);
    // 	virtual ~CPointX(void);
    	~CPointX(void);
    
    	int getX(){return m_x;}
    	int getY(){return m_y;}
    
    	void setX(int x){m_x = x;}
    	void setY(int y){m_y = y;}
    
    protected:
    	int m_x;
    	int m_y;
    };
    
    
    #include "StdAfx.h"
    #include "PointX.h"
    
    CPointX::CPointX(void)
    {
    	printf("point construct!\n");
    	m_x = 0;
    	m_y = 0;
    }
    
    CPointX::~CPointX(void)
    {
    	printf("point destruct!\n");
    }
    

    #pragma once
    #include "pointx.h"
    
    class CColorPointX :
    	public CPointX
    {
    public:
    	CColorPointX(void);
    // 	virtual ~CColorPointX(void);
    	~CColorPointX(void);
    
    
    protected:
    	int m_color;
    };
    

    CColorPointX::CColorPointX(void)
    {
    	printf("color point construct!\n");
    	m_color = 0;
    }
    
    CColorPointX::~CColorPointX(void)
    {
    	printf("color point destruct!\n");
    }
    

    main函数如下:

    int _tmain(int argc, _TCHAR* argv[])
    {
    
    	CColorPointX *pline = new CColorPointX();
    	assert(pline != NULL);
    
    	delete pline;
    	pline = NULL;
    
    // 	CPointX* ppt = new CColorPointX();
    // 	delete ppt;
    
    	return 0;
    }
    


    输出结果如下:

    point construct!

    color point construct!

    color point destruct!

    point destruct!


    2.将上述两个类中的析构函数改为虚析构函数,main函数不变,输出结果如下:

    point construct!

    color point construct!

    color point destruct!

    point destruct!

    3.不使用虚析构函数,main函数如下:

    int _tmain(int argc, _TCHAR* argv[])
    {
    
    // 	CColorPointX *pline = new CColorPointX();
    // 	assert(pline != NULL);
    // 
    // 	delete pline;
    // 	pline = NULL;
    
    	CPointX* ppt = new CColorPointX();
    	delete ppt;
    
    	return 0;
    }
    

    输出结果:

    point construct!

    color point construct!

    point destruct!

    4.使用虚析构函数,main函数同3,输出结果如下:

    point construct!

    color point construct!

    color point destruct!

    point destruct!


    总结:虚析构函数解决了使用基类指针删除派生类对象的问题。


    展开全文
  • 虚析构函数定义作用虚析构函数是为了解决基类的指针指向派生类对象,并用基类的指针删除派生类对象。 如果某个类不包含虚函数,那一般是表示它将不作为一个基类来使用。当一个类不准备作为基类使用时,使析构...
  • ()C++基类的虚析构函数 #include&lt;iostream&gt; using namespace std; class Base { private: int i; public: Base(){ cout &lt;&lt; "Base count " &lt;&lt; endl; } ...
  • 1、类中所有的成员函数都是纯虚函数,2、没有定义成员变量。 因为接口只负责描述类的行为和功能,不需要实现,而是由它的派生类来实现。 至于普通抽象类,只要有一个成员函数被声明为纯虚函数,那它就是抽象类,这...
  • C++中虚析构函数作用

    2014-01-14 14:44:58
    我们知道,用C++开发的时候,用来做基类的类的析构函数一般都是函数。可是,为什么要这样做呢?下面用一个小例子来说明:   有下面的两个类: class ClxBase { public:  ClxBase() {};  virtual ~...
  • 类型需要虚析构函数的另外一个特征 是该类型具有指针成员或引用成员。如果有指针成员和引用成员,则该类型通常需要实现析构函数以及拷贝操作。   通常,一个实现了析构函数的类型同时也需要实现拷贝构造函数与...
  • 虚函数的实现原理: 实现虚函数需要对象附带一些额外信息,以使对象在运行时可以确定该调用哪个虚函数。对大多数编译器来说,这个额外信息的具体形式是一个称为vptr(虚函数表指针)的指针。vptr指向的是一个...
  • c++析构函数、虚析构函数、纯虚析构函数详解
  • C++中的虚析构函数到底什么时候有用的,什么作用呢。 一.虚析构函数作用 总的来说虚析构函数是为了避免内存泄露,而且是当子类中会有指针成员变量时才会使用得到的。也就说虚析构函数使得在删除指向子类对象的基类...
  • c++虚析构函数作用

    2018-05-13 12:11:36
    虚析构函数作用 总的来说虚析构函数是为了避免内存泄露,而且是当子类中会有指针成员变量时才会使用得到的。也就说虚析构函数使得在删除指向子类对象的基类指针时可以调用子类的析构函数达到释放子类中堆内存的...
  • 虚析构函数作用

    2020-06-06 21:08:25
    虚析构函数作用 析构函数的作用 类的析构函数是为了释放内存资源,析构函数不被调用的话就会造成内存泄漏。 虚析构函数 定义为虚析构函数是为了当用一个基类的指针删除一个派生类的对象时,派生类的析构函数会被...
  • 本篇文章是对C++中虚析构函数作用进行了详细的分析介绍,需要的朋友参考下
  • 我们知道,用C++开发的时候,用来做基类的类的析构函数一般都是函数。可是,为什么要这样做呢?下面用一个小例子来说明:有下面的两个类:class ClxBase{public:ClxBase() {}virtual ~ClxBase() { cout<virtual...
  • 虚析构函数:当且仅当类里包含至少一个虚函数的时候才去声明虚析构函数,无故的声明虚析构函数和永远不去声明一样是错误的; class <类名> { virtual ~<类名>(); … }; 即:virtual ~A(); 纯虚析构函数:抽象类是...
  • 析构函数
  • 虚析构函数

    2019-09-07 18:11:21
    C++中的虚析构函数到底什么时候有用的,什么作用呢。 一.虚析构函数作用 总的来说虚析构函数是为了避免内存泄露,而且是当子类中会有指针成员变量时才会使用得到的。也就说虚析构函数使得在删除指向子类对象的基类...
  • C++中虚析构函数作用.pdf
  • 基础知识: C++中,一个类在建成时...即使析构函数不被声明,也会隐式调用析构函数。 那么,当一个派生类继承了一个基类,这时候调用析构函数,会发生什么呢? #include <iostream> using namespace std;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,666
精华内容 11,066
关键字:

虚析构函数的作用