C++中new 的用法大全 详细(3)

我们经常会通过new来动态创建一个数组，例如： char* s = new char[100]; …… delete s;

严格的说，上述代码是不正确的，因为我们在分配内存时使用的是new[]，而并不是简单的new，但释放内存时却用的是delete。正确的写法是使用delete[]： delete[] s;

但是，上述错误的代码似乎也能编译执行，并不会带来什么错误。事实上，new与new[]、delete与delete[]是有区别的，特别是当用来操作复杂类型时。假如针对一个我们自定义的类MyClass使用new[]：

MyClass* p = new MyClass[10];

上述代码的结果是在堆上分配了10个连续的MyClass实例，并且已经对它们依次调用了构造函数，于是我们得到了10个可用的对象，这一点与Java、C#有区别的，Java、C#中这样的结果只是得到了10个null。换句话说，使用这种写法时MyClass必须拥有不带参数的构造函数，否则会发现编译期错误，因为编译器无法调用有参数的构造函数。

当这样构造成功后，我们可以再将其释放，释放时使用delete[]： delete[] p;

当我们对动态分配的数组调用delete[]时，其行为根据所申请的变量类型会有所不同。如果p指向简单类型，如int、char等，其结果只不过是这块内存被回收，此时使用delete[]与delete没有区别，但如果p指向的是复杂类型，delete[]会针对动态分配得到的每个对象调用析构函数，然后再释放内存。因此，如果我们对上述分配得到的p指针直接使用delete来回收，虽然编译期不报什么错误（因为编译器根本看不出来这个指针p是如何分配的），但在运行时（DEBUG情况下）会给出一个Debug assertion failed提示。

到这里，我们很容易提出一个问题——delete[]是如何知道要为多少个对象调用析构函数的？要回答这个问题，我们可以首先看一看new[]的重载。 class MyClass { int a; public:

MyClass() { printf(\ ~MyClass() { printf(\};

void* operator new[](size_t size) {

void* p = operator new(size);

printf(\ return p; }

// 主函数

MyClass* mc = new MyClass[3]; printf(\delete[] mc;

运行此段代码，得到的结果为：（VC2005）

calling new[] with size=16 address=003A5A58 ctor ctor ctor

address of mc=003A5A5C dtor dtor dtor

虽然对构造函数和析构函数的调用结果都在预料之中，但所申请的内存空间大小以及地址的数值却出现了问题。我们的类MyClass的大小显然是4个字节，并且申请的数组中有3个元素，那么应该一共申请12个字节才对，但事实上系统却为我们申请了16字节，并且在operator new[]返后我们得到的内存地址是实际申请得到的内存地址值加4的结果。也就是说，当为复杂类型动态分配数组时，系统自动在最终得到的内存地址前空出了4个字节，我们有理由相信这4个字节的内容与动态分配数组的长度有关。通过单步跟踪，很容易发现这4个字节对应的int值为0x00000003，也就是说记录的是我们分配的对象的个数。改变一下分配的个数然后再次观察的结果证实了我的想法。于是，我们也有理由认为new[] operator的行为相当于下面的伪代码：

template T* New[](int count) {

int size = sizeof(T) * count + 4; void* p = T::operator new[](size); *(int*)p = count; T* pt = (T*)((int)p + 4); for(int i = 0; i < count; i++) new(&pt[i]) T(); return pt; }

上述示意性的代码省略了异常处理的部分，只是展示当我们对一个复杂类型使用new[]来动态分配数组时其真正的行为是什么，从中可以看到它分配了比预期多4个字节的内存并用它来保存对象的个数，然后对于后面每一块空间使用placement new来调用无参构造函数，这也就解释了为什么这种情况下类必须有无参构造函数，最后再将首地址返回。类似的，我们很容易写出相应的delete[]的实现代码： template void Delete[](T* pt) {

int count = ((int*)pt)[-1]; for(int i = 0; i < count; i++) pt[i].~T();

void* p = (void*)((int)pt – 4); T::operator delete[](p); }

由此可见，在默认情况下operator new[]与operator new的行为是相同的，operator delete[]与operator delete也是，不同的是new operator与new[] operator、delete operator与delete[] operator。当然，我们可以根据不同的需要来选择重载带有和不带有―[]‖的operator new和delete，以满足不同的具体需求。

把前面类MyClass的代码稍做修改——注释掉析构函数，然后再来看看程序的输出： calling new[] with size=12 address=003A5A58 ctor ctor ctor

address of mc=003A5A58

这一次，new[]老老实实的申请了12个字节的内存，并且申请的结果与new[] operator返回的结果也是相同的，看来，是否在前面添加4个字节，只取决于这个类有没有析构函数，当然，这么说并不确切，正确的说法是这个类是否需要调用构造函数，因为如下两种情况下虽然这个类没声明析构函数，但还是多申请了4个字节：一是这个类中拥有需要调用析构函数的成员，二是这个类继承自需要调用析构函数的类。于是，我们可以递归的定义―需要调用析构函数的类‖为以下三种情况之一：

1 显式的声明了析构函数的

2 拥有需要调用析构函数的类的成员的 3 继承自需要调用析构函数的类的

类似的，动态申请简单类型的数组时，也不会多申请4个字节。于是在这两种情况下，释放内存时使用delete或delete[]都可以，但为养成良好的习惯，我们还是应该注意只要是动态分配的数组，释放时就使用delete[]。 释放内存时如何知道长度

但这同时又带来了新问题，既然申请无需调用析构函数的类或简单类型的数组时并没有记录个数信息，那么operator delete，或更直接的说free()是如何来回收这块内存的呢？这就要研究malloc()返回的内存的结构了。与new[]类似的是，实际上在malloc()申请内存时也多申请了数个字节的内容，只不过这与所申请的变量的类型没有任何关系，我们从调用malloc时所传入的参数也可以理解这一点——它只接收了要申请的内存的长度，并不关系这块内存用来保存什么类型。下面运行这样一段代码做个实验： char *p = 0;

for(int i = 0; i < 40; i += 4) {

char* s = new char[i];

printf(\ p = s; }

我们直接来看VC2005下Release版本的运行结果，DEBUG版因包含了较多的调试信息，这里就不分析了：

alloc 0 bytes, address=003A36F0 distance=3815152 alloc 4 bytes, address=003A3700 distance=16 alloc 8 bytes, address=003A3710 distance=16 alloc 12 bytes, address=003A3720 distance=16 alloc 16 bytes, address=003A3738 distance=24 alloc 20 bytes, address=003A84C0 distance=19848 alloc 24 bytes, address=003A84E0 distance=32 alloc 28 bytes, address=003A8500 distance=32 alloc 32 bytes, address=003A8528 distance=40 alloc 36 bytes, address=003A8550 distance=40

每一次分配的字节数都比上一次多4，distance值记录着与上一次分配的差值，第一个差值没有实际意义，中间有一个较大的差值，可能是这块内存已经被分配了，于是也忽略它。结果中最小的差值为16字节，直到我们申请16字节时，这个差值变成了24，后面也有类似的规律，那么我们可 …… 此处隐藏：2677字，全部文档内容请下载后查看。喜欢就下载吧 ……