在一个函数中定义了一个指针，需不需要在函数的末尾把该指针delete掉呢？c++中什么时候用delete呢？

今天，突然在想这个问题。其实简单的可以归总为一句话：

                                                                        在c++中，有new的地方必须有delete

在c++中，new和delete是用来分配内存和释放内存的两个操作符，正如c中的malloc和free一样。

因为malloc、calloc、realloc都是在堆上分配的，堆上分配的空间必须由用户自己来管理，如果不释放，就会造成内存泄漏。而栈上分配的空间是由编译器来管理的，具有函数作用域，出了函数作用域后系统会自动回收，不由用户管理，所以不用用户显式释放空间。

 

因此，如果你的函数里面声明指针的时候没有用到new来申请内存。就不用delete了。



参考该博客有详细的代码解释：c++详解【new和delete】

C++ delete this
前言
can only be used with new
access member variable after delete this
參考連結

前言
本篇基於“delete this” in C++，並完善了原文中提供的幾個例子。
can only be used with new
只有當物件是使用new創建的，我們才能使用delete this來銷毀它。
定義一個名為A的類別，函數fun裡用到了delete this：
class A{
public:
    void fun(){
        delete this;
    }
};

使用new創建一個A類別的物件，並使ptr1指向它。然後呼叫fun這個函數，用來銷毀該物件：
A *ptr1 = new A;
ptr1->fun();
ptr1 = nullptr; // make ptr NULL to make sure that things are not accessed using ptr.

以上這段代碼可以執行無誤。
再來看一個例子，如果沒有用new創建物件，卻使用了delete this：
A a;
a.fun();

則會造成以下錯誤：
a.out(24779,0x1164e25c0) malloc: *** error for object 0x7ffee89ff718: pointer being freed was not allocated
a.out(24779,0x1164e25c0) malloc: *** set a breakpoint in malloc_error_break to debug
Abort trap: 6

access member variable after delete this
在使用delete this後，存取成員變數是undefined behavior。
下面定義了一個名為B的類別。在建構子中會初始化它的三個成員變數。而在函數fun中，則會在delete this前後各輸出一次它的三個成員變數：
class B{
private:
    int x;
    std::string s;
    std::vector<int> v;
public:
    B(){
        x = 100;
        s = "abc";
        v.push_back(x);
    }
   
    void fun(){
        std::cout << "before delete this" << std::endl;
        std::cout << x << std::endl;
        std::cout << s << std::endl;
        std::cout << v.size() << " " << v[0] << std::endl;
    
        delete this;

        /* Invalid: Undefined Behavior */
        std::cout << "after delete this" << std::endl;
        std::cout << x << std::endl;
        std::cout << s << std::endl;
        std::cout << v.size() << " " << v[0] << std::endl;
    }
};

使用正確地方式來新建及銷毀B類別的物件：
B *ptr2 = new B;
ptr2->fun();
ptr2 = nullptr;

輸出為：
before delete this
100
abc
1 100
after delete this
100
abc
0 0

因為在delete this後存取成員變數是未定義的行為，所以我們可以看到，成員變數v在delete this前後並不一致。
以上兩個例子的代碼詳見cpp-code-snippets/delete_this.cpp。
參考連結
“delete this” in C++
cpp-code-snippets/delete_this.cpp

C++ delete陷阱

可能算不上陷阱这么严重，或者我可能危言耸听什么的，但这个确实是之前没有注意到的一个问题，最近一个小项目中确实吃了不少苦头。

我们知道，在C++ 动态内存操作的过程中，对于不再使用的分配过的内存一定要用delete来释放，简单的用法可以这么来说：


  
new和delete是成对出现，new[]和delete[]是成对出现的。


现在很少会犯忘记释放内存delete这样的错误，不过对于一个指针变量来说，并不是在不使用他后使用delete就万事大吉，这里delete过后最好置空，例如：



int *p=new int(1);
//do something
delete p;
p=NULL;//加上此句

因为delete只负责管理动态分配的堆中的内存，而对于指针变量p本身来说，作为局部变量，他就位于栈空间，当生命周期结束会自动被释放，但是如果在该局部变量的作用域再去使用他，也许程序不会因为动态内存问题崩溃，但有可能出现逻辑错误造成不可预知的结果。简单来说：


  
delete语句将申请的动态内存释放，但是原来的指针变量p仍然保存着这块内存的地址，这个时候，安全起见，我们人为的把delete过后的指针置为NULL。


通过单步调试就很容易看到结果： 


delete之前，左边是地址，右边是值 
 


delete之后，地址不变，但由于内存释放，值已经乱七八糟了。


—————————————————–补充———————————————

在《C++ Primer》（第5版）P410页，使用动态内存管理容易出错的三点：


  
内存泄漏——忘记delete 

  使用已经释放的内存(本文提到的)，通过释放内存后将指针置空检测这种错误。 

  同一块内存释放两次。


而第二种情况里，在delete之后指针就变成了了人们所说的空悬指针(dangling pointer)，指向一块曾经保存数据对象现在已经无效的内存测指针。

                                                    
 
 C++ delete错误 
 
 1. 指针通过 new 或 new[] ，向系统“申请”得到一段内存空间，这段内存空间必须在不需要将它释放了。 
 
int *  p  =   new   int [ 100 ]; 
int  girl[ 100 ];  
p  =  girl;  
delete [] p;
    灾难在 delete [] p  
时发生。 
我们原意是要释放p最初通过new int[100] 
而得到的内存空间，但事实上，p那时已经指向girl[100] 
了。结果，第一、最初的空间并没有被释放。第二、girl[100] 
 本由系统自行释放，现在我们却要强行释放它。
2. 一个指针被删除时，应指向最初的地址
 
  当一个指针通过 +,- 等操作而改变了指向；那么在释放之前，应确保其回到原来的指向。如下所示：在 delete [] p 时，p指向的是第二个元素，结果该释放将产生错位：第一个元素没有被释放，而在最后多删除了一个元素
 
 
int   * p  =   new   int [ 3 ];
* p  =   1 ;
cout  <<   * p  <<  endl;
p ++ ;  // p的指向改变了，指向了下一元素 
* p  =   2 ;
cout  <<   * p  <<  endl;
delete [] p;  // 错误的释放
p -- ;
delete [] p;
 
 但当我们的指针指向变化很多次时，在释放前要保证一步不错地一一退回，会比较困难。所以另一方法是在最初时“备份”一份。在释放时，直接释放该指针即可。 
 
 
int *  p  =   new   int [ 3 ];
int *  pbak  =   * p;  // 备份
 // 移动 p 
……
delete [] pbak;  // 释放
 
 
由于pbak正是指向p最初分配后的地址，我们删除pbak,就是删除p最初的指向。此时我们不能再删除一次p。这也就引出new / delete 及 new[] / delete[] 在本章的最后一个问题。

3. 已释放的空间，不可重复释放
第一种最直接： 
 
 
int *  p  =   new   int ( 71 );
cout  <<   * p  <<  endl;　
delete p;  // OK! 
delete p;  // ERROR! 重复删除p
 
 
 第二种为重复删除同一指向的多个指针 
 
 
int *  p1  =   new   int ( 71 );
int *  p2  =  p1;  // p2和p1 现在指向同一内存地址
cout  <<   * p1  <<  endl;
cout  <<   * p2  <<  endl;
delete p1;  // OK 
delete p2;  // ERROR! p2所指的内存，已通过delete p1而被释放，不可再delete一次
 
 
同样的问题，如果你先删除了p2，则同样不可再删除p1
 
 
 
delete p2;  // OK 
delete p1;  // ERROR
 
 
 第三种为删除指向某一普通变量的指针 
 
 
int  a  =   100 ;
int *  p  =   & a;
delete p;  // ERROR
 
 
 p 不是通过new 得到新的内存空间，而是直接指向固定变量a。所以删除p等同要强行剥夺a的固有空间,会导致出错。 
 
 4.当出现堆溢出的时候
 
 
char* p = new char[5];
char *str = "12345";//实际长度为6
strcpy(p,str);
delete[] p; //ERROR
                                                    
转载于:https://my.oschina.net/superpdm/blog/466303