动态对象创建（二）重载new和delete

动态对象创建（二）重载new和delete

前言

上文我简单介绍了一下动态对象创建的方法，这一篇文章的内容主要是对重载new和delete做一些讲解，也希望能够得到博友们的指点，在这里谢过大家。

通常我们为了一些目的而使用new和delete的内存分配系统，但是在特殊情况下，它并不能够满足需要。最常见的改变分配系统的原因是出于效率考虑：也许要创建和销毁一个特定的类的非常多的对象以至于这个运算变成了速度的瓶颈。C++允许重载new和delete来实现我们自己的存储分配方案，所以可以用它来处理问题。

另一个问题就是堆碎片：分配不同大小的内存可能会在堆上产生很多碎片，以至于很快用完内存。虽然内存可能还有，但是由于都是碎片，也就找不到足够大的内存块满足需要。通过为特定类创建自己的内存分配器，可以确保这种情况不会发生。

当我们在重载operator new()和operator delete()时，我们只是改变了原有的内存分配方法。编译器将用重载的new代替默认版本去分配内存，然后为那个内存调用构造函数。所以，虽然当编译器看到new时，编译器分配内存并调用构造函数，但是当重载new时，可以改变的只是内存分配部分。

接下来，我分为三个部分详细讲解重载new和delete：重载全局new和delete、对于一个类重载new和delete以及为数组重载new和delete。

重载全局new和delete

当我们重载全局的new和delete的时候，可想而知，就会使默认版本完全不能被访问--甚至在这个重新定义里也不能调用它们。

重载的new必须有一个size_t参数。这个参数由编译器产生并传递给我们，它是要分配内存的对象的长度。必须返回一个指向等于这个长度（或者大于这个长度）的对象的指针。如果没有找到存储单元（在这种情况下，构造函数不被调用），则返回一个0。然后如果找不到存储单元，不能仅仅返回0，我们还应该调用new-handler或产生一个异常信息之类的事，告诉这里出现了问题。

我们首先需要明白的一点就是：operator new()的返回值是一个void*，而不是指向任何特定类型的指针。所做的是分配内存，而不是完成一个对象建立--直到构造函数调用了才完成对象的创建，它是编译器确保做的动作，不在我们的控制范围之内了，所以我们就没有必要考虑。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<algorithm>
 #define inf 0x7fffffff
 using namespace std;

 void* operator new(size_t sz)
 {
     printf("operator new: %d Bytes\n",sz);
     void* m = malloc(sz);
     if (!m) puts("out of memory");
     return m;
 }

 void operator delete(void* m)
 {
     puts("operator delete");
     free(m);
 }

 class S
 {
 public:
     S() {puts("S::S()"); }
     ~S() {puts("S::~S()"); }
 private:
     int an[];
 };

 int main()
 {
     puts("creating & destroying an int");
     int* q = new int();
     delete q;
     puts("creating & destroying an int[]");
     int* p = new int[]();
     delete []p;
     puts("creating & destroying an s");
     S* s = new S;
     delete s;
     puts("creating & destroying S[3]");
     S* sa = new S[];
     delete []sa;
     return ;
 }

对于一个类重载new和delete

为一个类重载new和delete的时候，尽管不必显式的使用static，但是实际上仍是在创建static成员函数。它的语法也和重载任何其它运算符一样。当编译器看到使用new创建自己定义的类的对象时，它选择成员版本的operator new()而不是全局版本的new()。但是全局版本的new和delete仍为所有其他类型对象使用（除非它们也有自己的new和delete）。这个和全局变量、局部变量的意思是一样的，应该很好懂吧。

 #include<iostream>
 #include<cstddef>
 #include<fstream>
 #include<new>
 using namespace std;
 ofstream out("Framis.out");

 class Framis
 {
 public:
     enum{psize =  };
     Framis() {out<< "Framis()" <<endl; }
     ~Framis() {out<< "~Framis() ... " <<endl; }
     void* operator new(size_t) throw (bad_alloc);
     void operator delete(void*);
 private:
     enum{sz =  };
     char c[sz];
     static unsigned char pool[];
     static bool alloc_map[];
 };
 unsigned char Framis::pool[psize*sizeof(Framis)];
 bool Framis::alloc_map[psize]={false};

 void* Framis::operator new(size_t sz) throw(bad_alloc)
 {
     for (int i=; i<psize; ++i) {
         if (!alloc_map[i]) {
             out<< "using block " << i << " ... ";
             alloc_map[i]=true;
             return pool+(i*sizeof(Framis));
         }
     }
     out<< "out of memory" <<endl;
     throw bad_alloc();
 }

 void Framis::operator delete(void* m)
 {
     if (!m) return;
     unsigned long block = (unsigned long)m-(unsigned long)pool;
     block /= sizeof(Framis);
     out<< "freeing block " << block <<endl;
     alloc_map[block]=false;
 }

 int main()
 {
     Framis* f[Framis::psize];
     try {
         for (int i=; i<Framis::psize; i++) {
             f[i]=new Framis;
         }
         new Framis;
     } catch(bad_alloc) {
         cerr<< "Out of memory!" <<endl;
     }
     delete f[];
     f[]=;
     Framis* X=new Framis;
     delete X;
     for (int j=; j<Framis::psize; j++) {
         delete f[j];
     }
     return ;
 }

为数组重载new和delete

上一段文字中我们讲到如果为一个类重载operator new()和operator delete()，那么无论何时创建这个类的一个对象都将调用这些运算符。但是如果要创建这个类的一个对象数组的时候，全局operator new()就会被立即调用，用来为这个数组分配足够的内存。对此，我们可以通过为这个类重载运算符的数组版本，即operator new[]和operator delete[]，来控制对象数组的内存分配。

 #include<iostream>
 #include<fstream>
 #include<new>
 using namespace std;
 ofstream trace("ArrayOperatorNew.out");

 class Widget
 {
 public:
     Widget() {trace<< "*" <<endl; }
     ~Widget() {trace<< "~" <<endl; }
     void* operator new(size_t sz) {
         trace<< "Widget::new: " << sz << " byte" <<endl;
         return ::new char[sz];
     }
     void operator delete(void* p) {
         trace<< "Widget::delete" <<endl;
         ::delete []p;
     }
     void* operator new[](size_t sz) {
         trace<< "Widget::new[]: " << sz << " bytes" <<endl;
         return ::new char[sz];
     }
     void operator delete[](void* p) {
         trace<< "Widget::delete[]" <<endl;
         ::delete []p;
     }
 private:
     enum{sz= };
     int an[sz];
 };

 int main()
 {
     trace<< "new Widget" <<endl;
     Widget* w=new Widget;
     trace<<endl<< "delete Widget" <<endl;
     delete w;
     trace<<endl<< "new Widget[25]" <<endl;
     Widget* wa=new Widget[];
     trace<<endl<< "delete []Widget" <<endl;
     delete []wa;
     return ;
 }

总结

1：对于C++中的动态对象创建又有了新的认识，学习了重载new和delete

2：C++空类的大小是1

3：最让我激动的就是：C++程序把运行结果写入新创建的文档里面，这个和ACM里常用的文件读写还是不一样滴。

好吧，继续努力！！！