C++类的delete的一些疑惑

 

    昨天晚上瞎逛博客，发现一个博主有这样的问题，地址已经忘记了，所以直接把有问题的代码贴过来，就是关于一个类对象的指针，当delete 这个指针的时候，指向的对象应该被析构了，为什么还能调用该对象的方法呢？

 

 

#include <iostream>
using namespace std;
class X
{
 public:
  X(){
    cout << "X()" << endl;
     }
  ~X(){
    cout << "~X()" << endl;
  }
  void show(){
   cout << "show()" << endl;
  }
};
int main(){

 X *x = 0;
 cout << x << endl;
 {
    X *xx = new X();
    x = xx;
    cout << xx << endl;
 }
   delete x;
   x->show();
   cout << x << endl;
   return 0;
} 

     执行结果：

 

0

X()

0x9210f0

~X()

show()

0x9210f0

 

     这个的执行结果就是最后一个Show还是被执行了。

 

    这让我想到了文件管理系统中的删除文件的概念，其实在运行过程中，delete指针和删除文件的行为是类似的，主体依旧保留着，只是将登记在系统中的索引给删除了。delete对象还多一步就是调用析构函数。也就是说，该指针所指区域已经从“被占用” 被标记为“可用”。但里面的东西并没有及时被覆盖，而该指针在delete 调用后没有被置为NULL，所以指向的地址不变。两个都是一样的东西，当然可用继续调用原对象的成员函数了。但这样的行为是很危险的，如果运行一段时间后，该“可用”的对象地址被另一个东西占用后，再次这样调用的结果就是灾难性的了，不是崩溃起码也是读入错误的行为。

    所以一个好的习惯是delete后将指针置为NULL，不在管原来那个东西了。

    但问题到这里没完，如果说这个类过于简单了不具代表性，那我就用昨天实现的AutoBuf类稍加改造来做个测试。

 

 

#include <iostream>
#include <fstream>
#include "mem.h"
using namespace std;
const int bufSize=10;
struct AutoBuf
{
	int cur;//当前数据的索引
	int* buf;//数据缓存
	int size;//缓存区现有数据大小
	bool isLast;//是否已经从文件读完
	ifstream in;
	AutoBuf()
	{
		cout<<"AutoBuf() call"<<endl;
		cur=0;
		size=0;
		isLast=false;
		buf=new int[bufSize];
	}
	~AutoBuf()
	{
		cout<<"~AutoBuf() call"<<endl;
		in.close();
		delete[] buf;
	}
	void AttachFile(const char* filename)
	{
		in.open(filename);
	}
	int read()//从指定文件中读取
	{
		if( !in.is_open() ){cout<<"file not open!"<<endl;return -1;}
		int i=0;
		while( i<bufSize && in>>buf[i] )
		{
			++i;
		}
		size=i;//buf中有多少个数据
//		cout<<"read size:"<<size<<endl;
		cur=0;
		if( size < bufSize ) isLast=true;
		return size;
	}
	void show()
	{
		for(int i=0;i<bufSize;++i)
		{
			cout<<buf[i]<<" ";
		}
		cout<<endl;
	}
};

void showTenIntHere(int * buf)
{
	for(int i=0;i<bufSize;++i)
	{
		cout<<buf[i]<<" ";
	}
	cout<<endl;
}


int main(){
	AutoBuf* buf;
	buf=new AutoBuf;
	int* recode = buf->buf;
	buf->AttachFile(".//data.txt");
	cout<<"Address of buf:"<<buf<<endl;
	cout<<"Address of buf's buf:"<<buf->buf<<endl;
	buf->read();
	buf->show();
	delete buf;
	cout<<"Address of buf:"<<buf<<endl;
	cout<<"Address of buf's buf:"<<buf->buf<<endl;
	buf->read();
	buf->show();
	cout<<"The recode address has: ";
	showTenIntHere(recode);
    return 0;
}

 

   程序运行的结果是：

 

AutoBuf() call

Address of buf:0x31110

Address of buf's buf:0x31228

1 2 3 4 5 6 7 8 9 10 

~AutoBuf() call

Address of buf:0x31110

Address of buf's buf:0x310f0

file not open!

200976 196804 1521819542 134276960 200729 0 1890852797 59232 201368 200944 

The recode address has: 201368 200944 3 4 5 6 7 8 9 10 

 

    简单说下该类，该类内部有一个int* 成员，在构造函数里分配资源，并且在析构的时候释放资源。该类的行为是从一个已经含有10个数字（1-10）的文件中读入10个数字，然后show方法是显示int* 所指的10个int。showTenIntHere 是显示从参数地址开始的位置显示10个整形。这个调用的过程如我前面所说，类的对象依旧，除了ifstream

对象在析构中被关闭外，其他部分执行起来一切正常，还有个问题是在delete类成员int * buf后，buf的地址发生变化，所以我打算验证原来int *buf指向的对象是否发生变化，结果是，除了两个变了以外其他一切正常（后来我扩大空间，改成从10-20，结果10个都正常了，估计是刚释放资源那两个地方就被占用了）。

    我觉得以上这些结果足够说明，为什么delete指针以后还可以通过指针使用对象了，析构只是执行析构函数里的一些资源处理的问题，比如视频程序，每个内存管理类都含有一个指向一个大内存块的指针，析构就是在对象没用时候，处理这些数据的，它并没有把对象给覆盖了，而内存的释放也仅仅是标记为可用，让别的程序或者本程序有资源继续使用，也不会覆盖对象。

 

 但我还有一个疑问：delete [] buf， buf是 int*类型， 这样的动作的行为是如何的？为什么buf的地址改变了？是什么原因？