做了几个关于C++对象数组的几个实验

missjiang

1、删除对象数组时无需指定数组的大小

1. 
   
2. class Student {
   
3.         char data[4];
   
4. public:
   
5.         ~Student()
   
6.         {
   
7.                 printf("~Student\n");
   
8.         }
   
9. };
   
10. 
    
11. int main()
    
12. {
    
13.         Student * a = new Student[3];
    
14.         delete[3] a;
    
15. 
    
16.         printf("------------------------------\n");
    
17. 
    
18.         Student * b = new Student[3];
    
19.         delete[] b;
    
20. 
    
21.         return 0;
    
22. }
    
23. 程序输出：
    
24. ~Student
    
25. ~Student
    
26. ~Student
    
27. ------------------------------
    
28. ~Student
    
29. ~Student
    
30. ~Student
    

复制代码

a和b都指向一个包含有3个student对象的数组，在删除对象数组时无需指定数组的大小，delete[3] a 和delete[] b是等价的。

2、对象数组占有的空间

1. 
   
2. class Student {
   
3.         char data[4];
   
4. public:
   
5.         void * operator new[] (size_t size)
   
6.         {
   
7.                 printf("sizeof(Student[10]) == %d\n", size);
   
8.                 return NULL;
   
9.         }
   
10.         /* 没有析构函数 */
    
11. };
    
12. 
    
13. class Teacher {
    
14.         char data[4];
    
15. public:
    
16.         /* 定义了析构函数 */
    
17.         ~Teacher() { printf("~Teacher\n"); };
    
18.         void * operator new[] (size_t size)
    
19.         {
    
20.                 printf("sizeof(Teacher[10]) == %d\n", size);
    
21.                 return NULL;
    
22.         }
    
23. };
    
24. 
    
25. int main(int argc, char* argv[])
    
26. {
    
27.         new Student[10];
    
28.         new Teacher[10];
    
29.         return 0;
    
30. }
    
31. 程序输出为：
    
32. sizeof(Student[10]) == 40
    
33. sizeof(Teacher[10]) == 44
    

复制代码

两者输出不同，我的理解和猜测是：
1、我们重载了new[]运算符，“void * operator new[] (size_t size)”中的参数size是对象数组的大小
2、Student没有析构函数，对象数组占有的空间为10*4
3、Teacher存在析构函数，对象数组占有的空间为10*4 + 4
4、Teacher[10]多出来的4个字节可能用来存储 Teacher[10]数组中的大小，对于如下代码：

1. 
   
2. int main()
   
3. {
   
4.     Teacher * teachers = new Teacher[3];
   
5.     delete[] teachers;
   
6. }
   

复制代码

使用delete[] teachers时：

• teachers指向的对象数组包括了数组中元素的数目
• 因此delete[]可以遍历该数组，调用每个Teacher的析构函数
• 最后delete[]使用free收回分配出去的44个字节。

而Student没有析构函数，delete[]时就自然就可以省去“遍历该数组，调用每个对象的析构函数”这一步，因此Student[10]数组中无需保存数组中元素的数目。

PS：我在VC++ 6.0中做了这两个实验，也许在其它系统中会有不同的输出。

[ 本帖最后由 missjiang 于 2007-9-25 13:44 编辑 ]

antigloss

无论删除什么（new 分配的）数组，都不需要指明数组大小，直接 delete [] p; 就可以了

namtso

删除数组的时候，指定数组大小是一种过时的做法，出于兼容，有些编译器不会报错，但有些编译器会给出一个警告。