C++对象内存空间变化的问题！只是引入一个析构函数而已！

如下是一份测试的代码，测试重载 new, new[], delete, delete[] 操作，申请内存的时候，其内部的操作。

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>

using namespace System;
using namespace std;

class people
{
private:
int arg;
int x, y;
char *name;
public:
people()
{
cout << "in deault constructor! " << endl;
}

people(int arg1, char *name1)
{
arg = arg1;
name = new char[strlen(name1) + 1];
memcpy(name, name1, strlen(name1) + 1);
};
void show()
{
cout << "arg = " << arg << ", name = " << name << endl;
}
void* operator new(size_t size);
void* operator new[](size_t size);
void operator delete(void *p);
void operator delete[](void *p);
};

void *people::operator new(size_t size)
{
char *p = new char[size];
printf("p = %X, size = %d \n", p, size);
return p;
}
void *people::operator new[](size_t size)
{
char *p = new char[size];
printf("p[] = %X, size = %d \n", p, size);
return p;
}
void people::operator delete(void *p)
{
printf("delete p = %X \n", p);
delete p;
}

void people::operator delete[](void *p)
{
printf("delete []p = %X \n", p);
delete p;
}

int main(array<System::String ^> ^args)
{

people p(12, "wkf");
p.show();

cout << "sizeof(people) = " << sizeof(people) << endl;
people *p1 = new people();
people *p2 = new people[3];

cout << "p1 = " << p1 << endl;
cout << "p2 = " << p2 << endl;

cout << "p2[0] = " << &p2[0] << endl;
cout << "p2[1] = " << &p2[1] << endl;
cout << "p2[2] = " << &p2[2] << endl;

memcpy(&p2[0], &p, sizeof(people));

delete p1;
delete []p2;

printf("hehe......\n");
getchar();
return 0;
}

程序运行结果如下：

arg = 12, name = wkf

sizeof(people) = 16

p = 42CC40, size = 16

in deault constructor!

p[] = 42CEB8, size = 48

in deault constructor!

in deault constructor!

in deault constructor!

p1 = 0042CC40

p2 = 0042CEB8

p2[0] = 0042CEB8

p2[1] = 0042CEC8

p2[2] = 0042CED8

delete p = 42CC40

delete []p = 42CEB8

hehe......

其中，执行：

people *p2 = new people[3];

的时候，调用了重载 operator new[] 函数，将申请 3 个对象的内存空间，一个对象是 16 个字节，所以，

总共需要申请 3 * 16 = 48 个字节。

所以，输出如下：

p[] = 42CEB8, size = 48

可以看到，我们返回的地址是 43CEB8，同时，在 main(); 中打印返回的地址是：

p2 = 0042CEB8

p2[0] = 0042CEB8

p2[1] = 0042CEC8

p2[2] = 0042CED8

完全对应上。

但是，如果我们在该类中增加 析构函数，如下：

~people()

{

cout << "in un constructor! " << endl;

}

其他的不用修改，然后，编译程序，输出如下：

arg = 12, name = wkf

sizeof(people) = 16

p = 42CC40, size = 16

in deault constructor!

p[] = 42CEB8, size = 52

in deault constructor!

in deault constructor!

in deault constructor!

p1 = 0042CC40

p2 = 0042CEBC

p2[0] = 0042CEBC

p2[1] = 0042CECC

p2[2] = 0042CEDC

in un constructor!

delete p = 42CC40

in un constructor!

in un constructor!

in un constructor!

delete []p = 42CEB8

hehe......

可以看到，执行如下代码：

people *p2 = new people[3];

申请了 52 个字节，52 = 3 * 16 + 4；

就是多了 申请 4 个字节的空间。

输出：

p[] = 42CEB8, size = 52

可以知道，返回的是 42CEB8 的地址，但是，p2 得到的地址是 42CEBC 的地址。

其中，42CEB8、42CEB9、42CEBA、42CEBB 然后到 42CEBC，中间正好是 4 个字节。

最后，执行

delete []p2;

的时候，传递给 operator delete[](); 函数的地址是 42CEB8，并不是 p2 的地址，而是 operator new[](); 中

申请内存的时候，返回的地址，那么，在中间产生的 4 个字节空间是做什么？

难道只是引入了 一个析构函数，就多产生了 4 个字节的空间。