delete this 的使用及注意事项

古城微笑少年丶 2022-06-10 02:19 274阅读 0赞

# delete this 的使用及注意事项 #

1.  this对象是必须是用 new操作符分配的（而不是用new\[\]，也不是用placement new，也不是局部对象，也不是global对象）；
2.  delete this后，不能访问该对象任何的成员变量及虚函数（delete this回收的是数据，这包括对象的数据成员以及vtable，不包括函数代码）；
3.  delete this后，不能再访问this指针。换句话说，你不能去检查它、将它和其他指针比较、和 NULL比较、打印它、转换它，以及其它的任何事情；

个人认为保证以上禁忌列表基本手段可以包括：

1.  将析构函数私有化（如果有子类，则protected化，保证子类能够正确继承）\--以保证对象必须使用new在堆上分配内存；
2.  提供（可以在仅仅在基类中）Destroy(void)函数，里面仅有一句delete this--以保证第三方能够将分配的内存回收；

先说说为什么要转这篇文章，原因是这样的一种方式可以让我们很好的回收对象内存，怎么说呢。  
比如你new了一个对象实例，然后呢他的使用者需要调用对象里的一个服务函数，想服务函数结束后就不再需要对象实例了，也就是说可以删除了，那么我们就可以通过在函数最后调用delete this将自己删除，也就是传说中的“自杀”。  
但为什么能自杀呢，我个人简单的理解就是类成员函数是真实存在的，不管你实例是否存在，只不过如果没有实例的话，类成员函数中的this指针就不存在了，所以这也是平时我们不能随意调用类成员函数的原因，那么当我们调用delete this时，他删除了对象自己，但我们的程序依然跑在那个成员函数的代码中，只要delete this后面没有什么数据是依赖于this指针的话也就不会出现问题了。  
当然这里有个例外的地方，就是不能在析构函数里调用delete this，否则就会进入死循环了。。。。。（这个你懂的，我不说了）

所以说知道了delete this的删除规则就可以很好的利用这个好东西了。

至于更具体的规则，你可以看下面的转载文章。

对象析构谈—— delete this 的使用及注意事项

In order to understand "delete this" :

First Step - dive into "delete p"

delete p 执行了哪些步骤？  
delete p 是一个两步的过程：调用析构函数，然后释放内存。

delete p产生的代码看上去是这样的（假设是Object\*类型的）：

delete原语可以看作如下这样一个过程：  
p->~Object();  
p->operator delete(p);

p->~Object() 语句调用p指向的Object对象的析构函数。  
p->operator delete(p) 语句调用对象p的内存释放原语 void operator delete(void\* p)。如果没有实现该方法，将调用系统的内存释放原语::operator delete(ptr)做释放该对象内存的操作。当然细节上并不这么简单，我们最后的实验部分会详细讨论。

Second Step - "delete this"

成员函数调用delete this合法吗？  
只要你小心，一个对象请求自杀(delete this)，是可以的。

以下是我对“小心”的定义：

你必须100%的确定，this对象是用 new分配的（不是用new\[\]，也不是用定位放置 new，也不是一个栈上的局部对象，也不是全局的，也不是另一个对象的成员，而是明白的普通的new）。

你必须100%的确定，该成员函数是this对象最后调用的的成员函数。

你必须100%的确定，剩下的成员函数（delete this之后的）不接触到this对象任何一块（包括调用任何其他成员函数或访问任何数据成员）。

你必须100%的确定，在delete this之后不再去访问this指针。换句话说，你不能去检查它，将它和其他指针比较，和NULL比较，打印它，转换它，对它做任何事。

自然，对于这种情况还要习惯性地告诫：当你的指针是一个指向基类类型的指针，而没有虚析构函数时（也不可以delete this）。

注意：因为是在类成员函数里面delete this的，所以在此语句以后，不能访问任何的成员变量及虚函数(调用虚函数必须对象实例存在以检查类型)，否则一定非法。

上面所说的在执行时不一定会报错，但尽量不要这么做。

Some test examples:

析构函数本身是不会释放内存的，  
除非在析构函数里面显示的使用delete操作符.

在对类指针使用delete时，实际发生了两个步骤。  
A:先是调用该类的析构函数，以做数据成员的释放工作，以及一些finish code，这一切由程序员自己定义。  
B:然后再调用operator delete(void\*)释放该对象实例的内存数据。这是一个对象在消亡之前的所做的最后动作。一般不要override这个函数，如果要，务必记住最后调用系统的::operator delete真正释放该对象所占用的内存。  
一般来说，内存释放释放的只能是数据段的内容（包括堆和栈，但释放栈上的内存由系统进行），而代码段的内存，除一些病毒攻击等非正常强行改写手段外，在内存中是永远不会释放/改变的，直到程序结束，因此在内存释放后也是可以访问的。所以，一般所谓的释放内存delete操作，是在数据段进行的释放。

可以试试下面的代码  
Example 1: 两步操作  
class x \{  
public :  
x()\{\}  
~x() \{  
printf("%s\\n","~x()");  
\}  
\};

void main() \{  
x\* p=new x;  
::operator delete(p); //调用delete内存释放原语，不会调用~x()，如果确实调用了系统::operator delete，就没有内存泄露（也可能由用户函数覆盖）  
delete p; //~x()依然会执行，operator delete中将会报错（最后将讨论）  
\}

Example 2: override重写的operator delete  
class x \{  
public :  
x()\{  
\}  
~x() \{  
printf("~x()\\n");  
//delete p; //这里若进行此操作则会陷入嵌套  
\}  
void operator delete(void \* ptr) \{  
printf("x::delete()\\n");  
\}  
\};

void main() \{  
x\* p=new x;  
delete p; //依次调用p的~x()和operator delete  
delete p; //不会报错，因为"operator delete" override了系统函数，没有进行::operator delete(this)操作。  
delete p; //同理依然不会报错  
\}

Example 3: 默认的operator delete  
class x \{  
public :  
x()\{  
//delete p; //构造时delete不会报错，只要确保以后不会用到该实例（包括delete p）。  
\}  
~x() \{  
printf("~x()\\n");  
\}  
\};

void main() \{  
x\* p=new x;  
delete p; //依次调用p的~x()和operator delete（其中调用了系统的::operator delete）  
//delete p; //报错，这里没有override，对象调用的是系统的::operator delete  
\}

进一步分析：

让我们看一下系统::operator delete的内部实现（in dbgdel.cpp）：  
void operator delete(  
void \*pUserData  
)  
\{  
\_CrtMemBlockHeader \* pHead;

RTCCALLBACK(\_RTC\_Free\_hook, (pUserData, 0));

if (pUserData == NULL)  
return;

\_mlock(\_HEAP\_LOCK);  
\_\_TRY

pHead = pHdr(pUserData);

\_ASSERTE(\_BLOCK\_TYPE\_IS\_VALID(pHead->nBlockUse)); //检查该段内存是否被程序占用。一般出现的如果内存已经释放了，又执行内存释放操作，这里就会报错

\_free\_dbg( pUserData, pHead->nBlockUse );

\_\_FINALLY  
\_munlock(\_HEAP\_LOCK);  
\_\_END\_TRY\_FINALLY

return;  
\}  
如果在里面设置断点，无论是直接调用::operator delete还是类似delete p调用对象的operator delete，如果没有人为override，都会进入这个函数，进行释放内存的操作。因此一个C++的类其实可以看做是有一个类似java的Object在内部进行操控：

class object \{  
public :  
object() \{ \}  
~object() \{ \}  
void operator delete(void \*ptr) \{  
::operator delete(ptr);  
\}  
\};

delete原语看起来会是如下的样子：  
p->~object();  
object::operator delete(p);  
因为代码段的内存是不会被释放的，因此无论对象p的内存有没有释放，这两个语句都会执行，不会因为p没有指向任何存在的对象而报错，只是在最后执行到::operator delete的时候，才会在执行\_ASSERTE(\_BLOCK\_TYPE\_IS\_VALID(pHead->nBlockUse))的时候报错。

Example 4: 代码段不会被释放  
class x \{  
public :  
x()\{printf("x()\\n"); \}  
~x() \{  
printf("~x()\\n");  
operator delete(this);  
//以下并不会报错  
int n=~get(34);//返回-6(~5)  
x(); //会连带调用x()->~x()->operator delete  
\}  
void operator delete(void \*p) \{ //这其实是一个静态函数，成员函数调用不能放在里面  
::operator delete(p);  
printf("x::delete()\\n");  
\}  
int get(int ) \{ //注意这个申明是合法的  
printf("x::get()\\n");  
return 5;  
\}  
\};

int main()  
\{  
x\* p=new x;  
x::x(); //合法的，会连带调用x()->~x()->operator delete，但会因为具体对象不存在而报错  
//p->x(); //调用非法，编译不通过  
delete p;  
int num = p->get(1); //不会报错，返回5  
\}

Example 5: 释放内存只释放数据段  
class x \{  
public :  
int n;  
x() \{  
printf("x()\\n");  
n=5;  
\}  
~x() \{  
printf("~x()\\n");  
\}  
void operator delete(void \*p) \{ //这其实是一个静态函数，成员函数调用不能放在里面  
::operator delete(p);  
printf("x::delete()\\n");  
\}  
int get(int ) \{  
printf("x::get()\\n");  
return n;  
\}  
void test() \{  
delete this;  
//以下并不会报错  
int n=this->get(34); //会得到一个非法值，不是5  
\}  
\};

int main()  
\{  
x\* p=new x;  
p->test();  
delete p;  
int num = p->get(1); //会得到一个非法值，不是5  
\}

以上实验在VS 2005下测试通过

以上转载 [http://blog.sina.com.cn/s/blog\_4ae178ba0100uopj.html][http_blog.sina.com.cn_s_blog_4ae178ba0100uopj.html]

## 在类的成员函数中调用delete this ##

在类的成员函数中能不能调用delete this？答案是肯定的，能调用，而且很多老一点的库都有这种代码。假设这个成员函数名字叫release，而delete this就在这个release方法中被调用，那么这个对象在调用release方法后，还能进行其他操作，如调用该对象的其他方法么？答案仍然是肯定 的，调用release之后还能调用其他的方法，但是有个前提：被调用的方法不涉及这个对象的数据成员和虚函数。说到这里，相信大家都能明白为什么会这样 了。

**根本原因**在于delete操作符的功能和类对象的内存模型。当一个类对象声明时，系统会为其分配内存空间。**在类对象的内存空间中，只有数据成员和虚函数表指针，并不包含代码内容，类的成员函数单独放在代码段中**。在调用成员函数时，隐含传递一个this指针，让成员函数知道当前是哪个对象在调用它。当 调用delete this时，类对象的内存空间被释放。**在delete this之后进行的其他任何函数调用，只要不涉及到this指针的内容，都能够正常运行**。一旦涉及到this指针，如操作数据成员，调用虚函数等，就会出现**不可预期**的问题。

为什么是不可预期的问题？**delete this之后不是释放了类对象的内存空间了么**，那么这段内存应该已经还给系统，不再属于这个进程。照这个逻辑来看，应该发生**指针错误**，**无访问权限之类的令系统崩溃**的问题才对啊？这个问题牵涉到操作系统的内存管理策略。**delete this释放了类对象的内存空间，但是内存空间却并不是马上被回收到系统中，可能是缓冲或者其他什么原因，导致这段内存空间暂时并没有被系统收回**。此时这段内存是可以访问的，你可以加上100，加上200，但是其中的值却是不确定的。当你获取数据成员，可能得到的是一串很长的未初始化的随机数；访问虚函数表，指针无效的可能性非常高，造成系统崩溃。

大致明白在成员函数中调用delete this会发生什么之后，再来看看另一个问题，如果在类的析构函数中调用delete this，会发生什么？实验告诉我们，会导致堆栈溢出。原因很简单，delete的本质是“为将被释放的内存调用一个或多个析构函数，然后，释放内存” (来自effective c++)。显然，**delete this会去调用本对象的析构函数，而析构函数中又调用delete this，形成无限递归，造成堆栈溢出，系统崩溃**。

\--------------------我是分界面--------------------

上面是某大牛的分析，而在实际的运行过程中使用delele this确实会直接出现错误。这是因为：在成员函数中调用delete this，首先会调用类的析构函数，this指针已删除，会出现指针错误。

下面是在XCode中使用delete this出现的错误：

malloc: \*\*\* error for object 0xbffffa18: pointer being freed was not allocated

//注意0xbffffa18即为this的地址  
\*\*\* set a breakpoint in malloc\_error\_break to debug

而在VS2010中使用delete this是直接导致 Debug Assertion Failed！

具体的描述是：**invalid null pointer**

**总结**：**在成员函数中调用delete this，会导致指针错误，而在析构函数中调用delete this，出导致死循环，造成堆栈溢出。**

PS：this是类中成员函数具有的一个附加的隐含形参，即指向该类对象的一个指针，它与调用成员函数的对象绑定在一起。同时**1.在普通的非const成员函数中：****this的类型是一个指向类类型的const指针，可以改变this指向的值，但是不能改变this所保存的地址**；**2.在const成员函数中，this的类型是一个指向const类类型对象的const指针，既不能改变this所指向的对象，也不能改变this所保存的地址**。

**注意：**

1.  成员函数中不能定义this形参，而是由编译器隐含地定义，但是可以在成员函数中显示使用this形参，不过也不是必须这么做。如果对类成员的引用没有限定，编译器会将这种引用处理成通过this指针的引用。
2.  **有一种情况下必须显式使用this：当我们需要将一个对象作为整体引用而不是引用对象的一个成员时。**
3.  **从const成员函数返回＊this**：**不能从const成员函数返回指向类对象的普通引用。const成员函数只能返回＊this作为一个const引用**。  
    
4.

以上转载 [http://blog.sina.com.cn/s/blog\_4b4cf2af0100ywgv.html][http_blog.sina.com.cn_s_blog_4b4cf2af0100ywgv.html]

[http_blog.sina.com.cn_s_blog_4ae178ba0100uopj.html]: http://blog.sina.com.cn/s/blog_4ae178ba0100uopj.html
[http_blog.sina.com.cn_s_blog_4b4cf2af0100ywgv.html]: http://blog.sina.com.cn/s/blog_4b4cf2af0100ywgv.html