精华内容
下载资源
问答
  • delete会调用析构函数吗
    千次阅读
    2021-09-25 07:43:30

    一.背景

    之前知道对象结束生命时,会自动调用析构函数.如果类中存在动态数组时,会在析构函数中会对动态数组对应的指针进行delete操作.不过一直对动态对象的delete操作和析构函数之间的关系没有太多关注.直到最近在看delete这块知识时,发现了这样的表述

    二.举例

    下面的代码中,在main函数的#if 1中动态创建了对象t,然后对t的成员变量进行了赋值,最后进行了delete t的操作.最后的执行结果是:

    //运行结果
    Object Release p Release

    这里实际上是delete操作做完后,就直接调用了析构函数.

    而#else中写的是在栈中创建的对象t.该种情况下调用析构函数实际上是在main()函数的{}作用域结束后.

    //实例代码
    #define _CRT_SECURE_NO_WARNINGS 1 #include <iostream> using namespace std; class Test { public: Test() { } ~Test() { cout << "Object Release" << endl; if (p) { delete p; p = NULL; cout << "p Release" << endl; } } public: char *p; }; int main() { #if 1 Test *t = new Test(); t->p = new char[10]; strcpy(t->p, "hello"); delete t; #else Test t; t.p = new char[10]; strcpy(t.p, "hello"); #endif return 0; }
    更多相关内容
  • 下面这段函数代码编译运行时没有问题的,不需要CPtr的定义 ---PtrUser.h class CPtr; // 预定义 class CPtrUser { public: CPreUser():m_pPtr(null); { } ~CPreUser() { delete m_pPtr; } void SetPtr...

    1. 所使用的类为预定义类

    下面这段函数代码编译运行时没有问题的,不需要CPtr的定义

    ---PtrUser.h

    class  CPtr; // 预定义
    class CPtrUser
    {
    public:
        CPreUser():m_pPtr(null);
        {
     
        }
        ~CPreUser()
        {
            delete m_pPtr;
        }
        void SetPtr(CPtr* p)
        {
            m_pPtr = p;
        }
    private:
        CPtr* m_pPtr;
    };

    当在Main中使用时,delete时,我们或许认为 m_pPtr 的析构函数会被调用

    ---main.cpp

    CPtrUser user = new CPtrUser();
    user->SetPtr(xxx);  // 其中xxx为CPtr类型指针
    delete user;
    

    但实际上,如果PtrUser.h先被包含的话,delete m_pPtr时,是不会调用CPtr析构函数的。如果期望析构函数被调用,可以通过#include“Ptr.h” 把 CPtr的定义放入到PtrUser.h中,这样C++编译器就能识别该类型,编译时,为delete添加析构函数调用。

    2. 转为父类,而父类没有声明virtual的虚析构函数

    Parent* p = new Child();
    delete p; 

    这种情况,Child的析构函数不会被调用。

    class Parent
    { 
    };
     
    class Child : public Parent
    {
    public:
       Child()
       {
       }
       ~Child()
       {
       }
    };

     要让被调用,可以简单修改为 :

    class Parent
    { 
    public:
       virtual ~Parent()
       {
       };
    };

    本文转自:内存泄漏-Delete不调用析构函数的两种情况_春夜喜雨的专栏-CSDN博客

    展开全文
  • C++析构函数delete关系

    千次阅读 2020-10-23 16:41:16
    在栈上的对象,作用域结束后自动调用析构函数(自动的),而delete用于在堆上创建的空间,执行delete后,程序执行该对象的析构函数,而不执行delete程序不会自动执行析构函数(也就是说,不使用delete它就不析构)...

    结论

    以下:

    在栈上的对象,作用域结束后自动调用析构函数(自动的),而delete用于在堆上创建的空间,执行delete后,程序会执行该对象的析构函数,而不执行delete程序不会自动执行析构函数(也就是说,不使用delete它就不析构)。

    示例

    class Factory
    {
    public:
        Factory(int n)
        {
            num = n;
            std::cout << "工厂 " << num << " 号启动了!" << std::endl;
        }
        ~Factory()
        {
            std::cout << "工厂 " << num << " 号关停了!" << std::endl;
        }
    private:
        int num = 0;
    };
    

    调用delete

    int main() {
    
        Factory one(1);
        Factory *two = new Factory(2);
        delete two;
        two = nullptr;
    
        std::cout << "Hello World!" << std::endl;
        system("pause");
        return 0;
    }
    

    来看看执行结果:

    在这里插入图片描述

    不调用delete

    不调用delete当然有内存泄漏了(这里仅做实验示例)。

    int main() {
    
        Factory one(1);
        Factory *two = new Factory(2);
    
        std::cout << "Hello World!" << std::endl;
        system("pause");
        return 0;
    }
    

    来看看结果(第二个对象没有析构):

    在这里插入图片描述

    展开全文
  • 也就说虚析构函数使得在删除指向子类对象的基类指针时可以调用子类的析构函数达到释放子类中堆内存的目的,而防止内存泄露的. 我们知道,用C++开发的时候,用来做基类的类的析构函数一般都是虚函数。可是,为什么要...
  • C++中new的用法及显示调用析构函数 <p>最近被问到了C++内存池的问题,其中不免涉及到在指定内存地址调用对象构造函数以及显示调用对象析构函数的情况。</p> C++中new的用法 new是C++中用于动态内存分配...

    C++中new的用法及显示调用析构函数
    <p>最近被问到了C++内存池的问题,其中不免涉及到在指定内存地址调用对象构造函数以及显示调用对象析构函数的情况。</p>
    

    C++中new的用法

    new是C++中用于动态内存分配的运算符,在C语言中一般使用malloc函数

    (1)plain new顾名思义就是普通的new,就是我们惯常使用的new。分配内存,调用构造函数,在C++中是这样定义的:

    1 void* operator new(std::size_t) throw(std::bad_alloc);
    2 void operator delete(void *) throw();

    plain new在分配失败的情况下,抛出异常std::bad_alloc而不是返回NULL,因此通过判断返回值是否为NULL是徒劳的。

    复制代码
     1 #include "stdafx.h"
     2 #include <iostream>
     3 using namespace std;
     4 char *GetMemory(unsigned long size)
     5 {
     6     char *p=new char[size];//分配失败,不是返回NULL
     7     return p;
     8 }
     9 
    10 int main()
    11 {
    12     try
    13     {
    14           char *p=GetMemory(10e11);// 分配失败抛出异常std::bad_alloc
    15           //...........
    16           if(!p)//徒劳
    17            cout<<"failure"<<endl;
    18           delete [] p;
    19     }
    20     catch(const std::bad_alloc &ex)
    21     {
    22           cout<<ex.what()<<endl;
    23     }
    24 
    25     return 0;
    26 }
    复制代码

     

    (2)nothrow new是不抛出异常的运算符new的形式。nothrow new在失败时,返回NULL。定义如下:

    1 void * operator new(std::size_t,const std::nothrow_t&) throw();
    2 void operator delete(void*) throw(); 
    复制代码
     1 #include "stdafx.h"
     2 #include <iostream>
     3 #include <new>
     4 using namespace std;
     5 char *GetMemory(unsigned long size)
     6 {
     7     char *p=new(nothrow) char[size];//分配失败,是返回NULL
     8     if(NULL==p)
     9           cout<<"alloc failure!"<<endl;
    10     return p;
    11 }
    12 
    13 int main()
    14 {
    15     try
    16     {
    17           char *p=GetMemory(10e11);
    18           //...........
    19           if(p==NULL)
    20                cout<<"failure"<<endl;
    21           delete [] p;
    22     }
    23     catch(const std::bad_alloc &ex)
    24     {
    25           cout<<ex.what()<<endl;
    26     }
    27     return 0;
    28 }
    复制代码

     

    (3)placement new意即“放置”,这种new允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new不用担心内存分配失败,因为它根本不分配内存,它做的唯一一件事情就是调用对象的构造函数。定义如下:

    1 void* operator new(size_t,void*);
    2 void operator delete(void*,void*);

    palcement new的主要用途就是反复使用一块较大的动态分配的内存来构造不同类型的对象或者他们的数组。placement new构造起来的对象或其数组,要显示的调用他们的析构函数来销毁,千万不要使用delete。

    复制代码
     1 #include "stdafx.h"
     2 #include <iostream>
     3 #include <new>
     4 using namespace std;
     5 class ADT
     6 {
     7     int i;
     8     int j;
     9 public:
    10     ADT()
    11     {
    12     }
    13     ~ADT()
    14     {
    15     }
    16 };
    17 
    18 int main()
    19 {
    20     char *p=new(nothrow) char[sizeof(ADT)+2];
    21     if(p==NULL)
    22           cout<<"failure"<<endl;
    23     ADT *q=new(p) ADT;  //placement new:不必担心失败
    24     // delete q;//错误!不能在此处调用delete q;
    25     q->ADT::~ADT();//显示调用析构函数
    26     delete []p;
    27     return 0;
    28 }
    复制代码

    使用placement new构造起来的对象或数组,要显式调用它们的析构函数来销毁(析构函数并不释放对象的内存),千万不要使用delete.这是因为placement new构造起来的对象或数组大小并不一定等于原来分配的内存大小,
    使用delete会造成内存泄漏或者之后释放内存时出现运行时错误。
     

    另:

    当使用new运算符定义一个多维数组变量或数组对象时,它产生一个指向数组第一个元素的指针,返回的类型保持了除最左边维数外的所有维数。例如:  

     int *p1 = new int[10];   

    返回的是一个指向int的指针int*  

    int (*p2)[10] = new int[2][10]; 

    new了一个二维数组, 去掉最左边那一维[2], 剩下int[10], 所以返回的是一个指向int[10]这种一维数组的指针int (*)[10].  

    int (*p3)[2][10] = new int[5][2][10];  new了一个三维数组, 去掉最左边那一维[5], 还有int[2][10], 所以返回的是一个指向二维数组int[2][10]这种类型的指针int (*)[2][10].     

    复制代码
    #include<iostream>
    

    #include <typeinfo>

    using namespace std;

    int main() {

    int *a = new int[34];

    int *b = new int[];

    int (*c)[2] = new

    int[34][2];

    int (*d)[2] = new int[][2];

    int (*e)[2][3] = new int[34][2][3];

    int (*f)[2][3] = new int[][2][3];

    a[0] = 1;

    b[0] = 1; //运行时错误,无分配的内存,b只起指针的作用,用来指向相应的数据

    c[0][0] = 1;

    d[0][0] = 1;//运行时错误,无分配的内存,d只起指针的作用,用来指向相应的数据

    e[0][0][0] = 1;

    f[0][0][0] = 1;//运行时错误,无分配的内存,f只起指针的作用,用来指向相应的数据

    cout<<typeid(a).name()<<endl;

    cout<<typeid(b).name()<<endl;

    cout<<typeid©.name()<<endl;

    cout<<typeid(d).name()<<endl;

    cout<<typeid(e).name()<<endl;

    cout<<typeid(f).name()<<endl;

    delete[] a; delete[] b; delete[] c;

    delete[] d; delete[] e; delete[] f;

    }

    输出结果:

    int *

    int *

    int (*)[2]

    int (*)[2]

    int (*)[2][3]

    int (*)[2][3]

    复制代码

    深入学习文献C++new用法深层剖析

     

    C++显示调用析构函数

    一、文章来由

    现在在写一个项目,需要用到多叉树存储结构,但是在某个时候,我需要销毁这棵树,这意味着如果我新建了一个树对象,我很可能在某处希望将这个对象的声明周期终结,自然会想到显示调用析构函数,但是就扯出来这么大个陷阱。

    二、原因

    在了解为什么不要轻易显示调用析构函数之前,先来看看预备知识。 
    为了理解这个问题,我们必须首先弄明白“堆”和“栈”的概念。

    1)堆区(heap) —— 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表。

    2)栈区(stack) —— 由编译器自动分配释放,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。

    我们构造对象,往往都是在一段语句体中,比如函数,判断,循环,还有就直接被一对“{}”包含的语句体。这个对象在语句体中被创建,在语句体结束的时候被销毁。问题就在于,这样的对象在生命周期中是存在于栈上的。也就是说,如何管理,是系统完成而程序员不能控制的。所以,即使我们调用了析构,在对象生命周期结束后,系统仍然会再调用一次析构函数,将其在栈上销毁,实现真正的析构。

    所以,如果我们在析构函数中有清除堆数据的语句,调用两次意味着第二次会试图清理已经被清理过了的,根本不再存在的数据!这是件会导致运行时错误的问题,并且在编译的时候不会告诉你!

    三、显示调用带来的后果

    如果硬要显示调用析构函数,不是不可以,但是会有如下3条后果:

    1)显式调用的时候,析构函数相当于的一个普通的成员函数

    2)编译器隐式调用析构函数,如分配了对内存,显式调用析构的话引起重复释放堆内存的异常

    3)把一个对象看作占用了部分栈内存,占用了部分堆内存(如果申请了的话),这样便于理解这个问题,系统隐式调用析构函数的时候,会加入释放栈内存的动作(而堆内存则由用户手工的释放);用户显式调用析构函数的时候,只是单纯执行析构函数内的语句,不会释放栈内存,也不会摧毁对象

    用如下代码表示:

    例1:

    class aaa
    {
    public:
        aaa(){}
        ~aaa(){cout<<"deconstructor"<<endl; } //析构函数
        void disp(){cout<<"disp"<<endl;} private: char *p; }; 

    void main()
    {
    aaa a;
    a.~aaa();
    a.disp();
    }

     

    分析:

    这样的话,显式两次destructor,第一次析构相当于调用一个普通的成员函数,执行函数内语句,显示第二次析构是编译器隐式的调用,增加了释放栈内存的动作,这个类未申请堆内存,所以对象干净地摧毁了,显式+对象摧毁

    例2:

    class aaa
    {
    public:
        aaa(){p = new char[1024];} //申请堆内存 ~aaa(){cout<<"deconstructor"<<endl; delete []p;} void disp(){cout<<"disp"<<endl;} private: char *p; }; 

    void main()
    {
    aaa a;
    a.~aaa();
    a.disp();
    }

    分析:

    这样的话,第一次显式调用析构函数,相当于调用一个普通成员函数,执行函数语句,释放了堆内存,但是并未释放栈内存,对象还存在(但已残缺,存在不安全因素);第二次调用析构函数,再次释放堆内存(此时报异常),然后释放栈内存,对象销毁

    四、奇葩的错误

    系统在什么情况下不会自动调用析构函数呢?显然,如果对象被建立在堆上,系统就不会自动调用。一个常见的例子是new…delete组合。但是好在调用delete的时候,析构函数还是被自动调用了。很罕见的例外在于使用布局new的时候,在delete设置的缓存之前,需要显式调用的析构函数,这实在是很少见的情况。

    我在栈上建树之后,显示调用析构函数,对象地址任然存在,甚至还可以往里面插入节点。。。

    其实析构之前最好先看看堆上的数据是不是已经被释放过了。

    #include <iostream>
    using namespace std;

    class A
    {

    private:
    int a;
    int* temp;
    bool heap_deleted;
    public:
    A(int _a);
    A(const A& _a);
    ~A();
    void change(int x);
    void show() const;
    };

    #endif

    ////////////a.cpp

    #include “a.hpp”
    A::A(int _a): heap_deleted(false)
    {
    temp = new int;
    *temp = _a;
    a = *temp;
    cout<< “A Constructor!” << endl;
    }

    A::A(const A& _a): heap_deleted(false)
    {
    temp = new int;
    *temp = _a.a;
    a = *temp;
    cout << “A Copy Constructor” << endl;
    }

    A::~A()
    {
    if ( heap_deleted == false){
    cout << "temp at: " << temp << endl;
    delete temp;
    heap_deleted = true;
    cout << “Heap Deleted!\n”;
    }
    else {
    cout << “Heap already Deleted!\n”;
    }

    void A::change(int x)
    {
    a = x;
    }

    void A::show() const
    {
    cout << "a = " << a << endl;
    }

    五、小结

    所以,一般不要自作聪明的去显示调用析构函数。

    展开全文
  • C++中的析构函数delete的关系

    千次阅读 2018-12-01 22:15:44
    版权声明:本文为博主原创文章,未经博主允许不得转载。... 析构函数 1.构造函数是初始化对象的非static数据成员,在函数体中还可以另外做一些事情;析构函数则是释放对象使用的资...
  • 的时候,离开作用域, 无需手动去调用对象的析构函数,系统自动调用~String. String *p = new String("hello"); delete p;//疑问:为什么这里还需要手动释放? 找到这样一个回答: 其实是两个意思. 前面的析构...
  • C++虚析构函数delete操作分析

    千次阅读 2020-10-30 12:22:44
    若在堆上申请的内存,则不需要调用delete释放内存,只需要调用析构函数。 1.1 析构函数与delete 在堆上申请的内存需要delete删除对象。在删除对象时既要执行析构又要释放内存。 class A { public: ~A(){} }; int m
  • C++显示调用析构函数

    2020-08-26 22:59:59
    C++中new的用法及显示调用析构函数 最近被问到了C++内存池的问题,其中不免涉及到在指定内存地址调用对象构造函数以及显示调用对象析构函数的情况。 C++中new的用法 new是C++中用于动态内存分配的运算符,在...
  • 是否可以手动调用析构函数

    千次阅读 2021-04-02 17:08:30
    虽然可以手动调用析构函数,但是对象的内存并没有释放。看一下代码示例: #include "stdafx.h" #include <iostream> #include <crtdbg.h> #ifdef _DEBUG #define new new(_NORMAL_BLOCK, __FILE__, _...
  • 释放使用常规new运算符分配的整个内存块,但它没有为定位new运算符在该内存块中创建的对象调用析构函数。 这种问题的解决方案是:显式地为使用定位new运算符创建的对象调用析构函数。 pc2->~JustTesting(); // 销毁...
  • 1. 所使用的类为预定义类 2. 转为父类,而父类没有声明virtual的虚析构函数
  • C++主动调用析构函数分析

    万次阅读 2017-12-05 19:41:49
    C++编程规范中都不支持显示的调用析构函数,部分文章中甚至说明析构函数是不能显示调用的,然而执行如下类似的操作编译器并不会报错,而且调用成功。 pa->~A(); 显示调用析构函数引起什么问题?为什么C++标准...
  • c++析构函数delete this指针https://blog.csdn.net/XHfight/article/details/52892439 首先,了解一下this指针: 当一个对象声明时,系统为这个对象分配一...第一步,针对此内存有一个(或更多)析构函数被调...
  • 析构函数调用

    2021-02-10 17:07:10
    多个类变量的函数共用内存,变量单独存放在不同的内存空间中,析构函数会释放这些内存空间 #include <iostream> #include <string.h> using namespace std; class person { private: int age; char ...
  • 使用new申请的对象,如果不主动delete掉,在程序运行结束的时候系统释放会调用对象的析构函数呢?我们写个小程序试试 #include <iostream> #include <string> class A { public: A(std::string ...
  • 析构函数delete

    千次阅读 2020-07-21 17:54:32
    析构函数delete区别 析构函数析构函数没有参数,没有返回值,不能重载; 理解:在创建对象时,系统自动调用构造函数进行初始化,这样需要申请内存,同样在程序结束时,或者需要销毁对象时,程序也自动...
  • C++没有调用析构函数

    千次阅读 2019-09-09 15:42:38
    在项目中遇到一个问题,析构函数没有调用产生了内存泄露。 具体见valgrind检测libevent内存泄露 我们看两个例子 demo1 class Test1; void del(Test1* obj){ delete obj; } class Test1{ public: Test1(){ ...
  • 如果不是引用传递的话,会调用析构函数(要注意重复delete的问题) 二: 不会。对象也可以作为函数的参数传递给函数,其转递方法与传递其他类型的数据一样,可采用值传递和地址传递两种方法。 值传递时是把对象的...
  • 关于C++手动调用析构函数的理解

    千次阅读 2018-11-19 19:06:07
    以前从来没有自己手动调用过析构函数,这里明显是要根据类型来调用析构函数啊。 踩个坑,可能理解的也没有很透彻 手动调用析构函数的小例子 参考别人的,写了个测试类。 class testDes { public: testDes() ...
  • 如果子类对象中有申请堆内存的...子类的析构函数没有调用,这样就造成内存泄露,解决办法:将父类析构函数声明为虚析构函数,然后子类析构函数中清理内存,这样在delete父类指针时候就会调用子类的析构函数了。 ...
  • delete一个void*指针:不调用析构函数

    千次阅读 2018-02-06 09:37:17
     一个类的指针,当使用delete函数来删除该指针时,会调用该指针当前类型的析构函数。  比如: classB* pClass = (classB*)new classA; delete pClass;  尽管该指针实际上是classA*类型,但将其转换为classB*...
  • 类的析构函数调用方式堆和栈结论系统在什么情况下不会自动调用析构函数呢?举例参考 堆和栈 为了理解这个问题,我们必须首先弄明白“堆”和“栈”的概念。 堆区(heap) —— 一般由程序员分配释放, 若程序员不...
  • 详解C++中的析构函数

    2020-12-17 04:29:04
    析构函数(Destructors),是对象的成员函数,没有返回值也没有参数,且一个类只有一个析构函数,当对象被销毁的时候调用,被销毁通常有这么几个情况。 函数执行结束 程序执行结束 程序块包含的局部变量 delete...
  • }   只有释放指针p(delete p),才会调用析构函数,否则不会调用析构函数。   4.4 多态的特殊情况   对于多态来说,当父类指针指向子类对象时,如下所示: Animal *animal = new Cat("Tom");   释放父类...
  • 析构函数何时被调用析构函数在下边3种情况时被调用:对象生命周期结束,被销毁时;主动调用delete ;(推荐学习:PHP编程从入门到精通)对象i是对象o的成员,o的析构函数被调用时,对象i的析构函数也被调用。PHP 5 ...
  • C++——析构函数什么时候被调用

    千次阅读 2020-09-07 10:25:29
    3.对象A是对象B的成员,B的析构函数调用时,对象A的析构函数也被调用。 举例来说: class A { public: A() {ma = new int(1000);} A(size sz) {ma = new int(sz);} virtual ~A() { delete ma;} in...
  • C++析构函数调用时机

    千次阅读 2020-06-28 18:03:40
    3、在堆区的对象,空间被delete调用析构函数;free不能调用; 代码验证:1 void test() { MyArry(10).getLen();//在栈区定义使用有参定义一个对象,并调用getLen方法,执行完立刻析构; cout << "在栈...
  • 析构函数调用时机

    千次阅读 2022-03-28 09:41:35
      当一个函数调用的时候,系统开辟一个栈帧给它,如果该函数抛出异常,那么该函数的栈帧就被销毁,有catch语句就捕获异常进行处理,没有catch语句就继续往调用他的函数抛,像这样一直抛的过程称为栈展开。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,197
精华内容 32,878
关键字:

delete会调用析构函数吗