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

       在类的成员函数中能不能调用delete this？答案是肯定的，能调用，而且很多老一点的库都有这种代码。假设这个成员函数名字叫release，而delete this就在这个release方法中被调用，那么这个对象在调用release方法后，还能进行其他操作，如调用该对象的其他方法么？答案仍然是肯定的，调用release之后还能调用其他的方法，但是有个前提：被调用的方法不涉及这个对象的数据成员和虚函数。不能访问该对象任何的成员变量及虚函数（delete this回收的是数据，这包括对象的数据成员以及vtable，不包括函数代码）；

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

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

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

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

//delete与析构函数
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中将会报错（最后将讨论）
}

//override operator delete原语
class x {
public :
	x(){}
	~x() {
		printf("~x()\n");
		//delete this;//这里进行delete将会陷入嵌套
	}
	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" 复写了系统函数，没有进行真正的::operator delete(this)操作。
}

//默认的operator delete原语
class x {
public :
	x(){}
	~x() {
		printf("~x()\n");
		//delete this;//这里进行delete将会陷入嵌套
	}
};

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

//代码段不会被释放
class x {
public :
	x(){}
	~x() {
		printf("~x()\n");
	}
	int get(int i){
		printf("x::get()\n");
		return 5;
	}
};

void main() {
	x* p=new x;
	delete(p);//释放对象内存，不释放代码段
	cout<<p->get(1)<<endl;//能正常调用，返回5
}

分析：

         delete原语看起来会是如下的样子：
           p->~object();
           object::operator delete(p);

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

总结：在成员函数中调用delete this得确保this是由new配置而来（非自定义的new版本，最原始的），且确保该成员函数是最后一个调用this的（delete后不能查看它﹑将它与其它指针或是 NULL 相比较﹑印出其值﹑对它转型等）。析构函数中调用delete this，出导致死循环，造成堆栈溢出。

PS：this是类中成员函数具有的一个附加的隐含形参，即指向该类对象的一个指针，它与调用成员函数的对象绑定在一起。

同时1.在普通的非const成员函数中：this的类型是一个指向类类型的const指针，可以改变this指向的值，但是不能改变this所保存的地址；2.在const成员函数中，this的类型是一个指向const类类型对象的const指针，既不能改变this所指向的对象，也不能改变this所保存的地址。

注意：

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