C++ new 和 delete 的重载

发现：类里面有几种成员函数是没有this指针的，也就是访问不了类的成员
 构造函数：有； 说明其实对象真正的初始化就是在初始化类表
 析构函数：有； 析构函数在最后的时刻才把对象空间释放
 普通函数：有
 static函数： 没有，但能访问静态成员
 重载的 new new[]成员函数： 没有， 因为对象的产生是先有空间在调用构造函数，new就是完成前个步骤的工作
 重载的 delete  delete[]成员函数： 没有， 因为对象的消失是先调用析构函数在回收对象空间，delete就是完成后面步骤的工作
 ......
  
new new[] delete delete[]在C++ 中是运算符，和sizoeof
底层的实现是通过C的malloc和free来实现的
存在的意义： C++ 中引入类，类的两个重要的函数：构造函数和析构函数
new  或 new[] 对象或一系列对象时， new操作符工作：1）先申请足够容纳存储对象的空间
  2）依次调用类的无参构造函数，所以类中要有无参构造函数


delete 或 delete[]: 1) 当面对释放的类型是基本类型的时候，两者是一样的效果
2）delete 和 delete[] 跟 free 最大的区别就是先调用类的析构函数析构对象
然后再执行free的操作，回收对象所存储的空间（注意：如果类中有指向堆空间的指针，这个操作是必须的)'
delete 对象 ，就是调用该对象的析构函数，在释放对象占用的空间
delete[]对象，如果对象是一系列对象，则循环调用每个对象的析构函数，再释放空间


new 和 delete的重载: 1)特定类中的重载； 2)全局范围的重载
new 通常的重载方式--> void* operator new(size_t size);
 可以在重载函数中加入其他参数，但第一个参数必须是size_t

 类型

下面的代码是参考自：http://blog.sina.com.cn/s/blog_3f56d7800100i1uf.html

/*
 * =====================================================================================
 *
 *       Filename:  new_delete_trace.cpp
 *
 *    Description:  
 *
 *        Version:  1.0
 *        Created:  08/22/2012 12:26:42 AM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  lsff (lsff), 
 *   Organization:  
 *
 * =====================================================================================
 */
#include <cstdlib>
#include <iostream>
using namespace std;

#define _DEBUG
#ifdef _DEBUG
void *operator new(size_t size, const char* file, int line)
{
cout<<"new size:"<<size<<endl;
cout<<file<<" "<<line<<endl;
// return mallloc(size);
return operator new(size);
}

void *operator new[](size_t size, const char* file, int line)
{
cout<<"new size:"<<size<<endl;
cout<<file<<" "<<line<<endl;
void *p = malloc(size);
cout<<reinterpret_cast<long>(p)<<endl;;
// return mallloc(size);
return p;
}
void operator delete(void *p)
{
long ip =reinterpret_cast<long>(p);
cout<<"delete "<<ip<<endl;
free(p);
}
void operator delete[](void *p)
{
cout<<"delte[]"<<reinterpret_cast<long>(p)<<endl;
free(p);
}

// 注意：上面连个函数体虽然相同，但一个都不能少
// delete[] 可以认为系统看到这个函数，就会循环地去调用该空间的
// 每个对象的析构函数再释放空间，但是delete 就只是调用第一个对象
// 的析构函数就释放空间，所以可以认为[] 区别了系统怎样去调用
// 底层的free,因为free 对数组和单个元素是不区分的，但是在free之前
// 系统通过[] 完成类似free的智能操作

void operator delete(void *p,const char*file ,int line)
{
cout<<"delete "<<file<<" "<<line<<endl;
free(p);
}

void operator delete[](void *p,const char*file ,int line)
{
cout<<"delete[] "<<file<<" "<<line<<endl;
free(p);
}
//上面两个函数是有用的，在异常发生的时候，默默无闻啊～～～

#define new  new(__FILE__, __LINE__)
#endif


class test
{
private:
int ival;
public:
test(){
throw int(3);
}
~test()
{
cout<<__FUNCTION__<<endl;
}
};

int  main()
{
// int *p=new int[5];
// delete (p);
// test *pc = new test[5];
// delete []pc;  // pc是指向对象的数组时必须使用delete[]，这样才会以此调用构造函数
try{
test *pc = new test;

delete pc;
}
catch(int a)
{
}
return 0;
}