如下测试delete与delete[]对吗?

[aaassd]

#include<iostream.h>
#include<fstream.h>
#include <stdlib.h>
void MyFunction(int nSize)
{
char* p= new char[nSize];
cout<<"The address p points is"<<(void*)p<<endl;
int i;
for(i=0; i<nSize;i++)
{
p[i] = 'a'+i;
}
for(i=0; i<nSize;i++)
{
cout<<p[i];
}
cout<<endl;
char *temp = p;
for(i=0; i<nSize;i++)
{
cout<<hex<<(temp[i]&0xff)<<endl; //以十六进制形式查看内存中的内容
}
cout<<endl;
delete p;
cout<<"The address p points before delete is"<<(void*)temp<<endl;
cout<<"The address p points after delete is"<<(void*)p<<endl; //查看P所指的地址
for(i=1; i<nSize;i++)
{
cout<<hex<<(temp[i]&0xff)<<endl; //以十六进制形式查看内存中的内容
}
cout<<hex<<(temp[1]&0xff)<<endl;
}
void main()
{
const int Size =6;
MyFunction(Size);
system("pause");
}

[Jinhao]

to chenyec(别笑我)：
我想知道你在哪儿看的delete不调用析构函数

[Jinhao]

或者这样，我们来打一架，谁赢谁说了算，OK?? :P

[Wolf0403]

支持辣子兄，呵呵。 delete 不能调用析构函数是一个天大的笑话。

struct A
{
A(){cout << "A::ctor" << endl;}
~A(){cout << "A::dtor" << endl;}
};

int main()
{
A * pa = new A;
delete pa;
}

楼上否认 delete 可以调用析构函数的兄弟可以拿去试试。

学 C++ 建议用几个经典著作，比如 C++ Primer, C++ Primer Plus 或者 The C++ Programming Language。那些说 delete 不能调用析构函数的烂书还是扔了好了。

[chenyec]

to:楼上下文
晕~
你没看题目吗？他那里说的是数组！！！
delete 能调用数组的所有析构函数吗？能的话，我马上把我这本书扔了~~~~~~

[Jinhao]

to chenyec(别笑我)
你也应该说清楚啊
delete 是会调用析构函数，但只会调用一个对象的，这也是为什么new[]分配的要用delete[]

[Wolf0403]

！！！彻底没什么可说的了，呵呵。

用 new 分配的内存应该用 delete 释放，new[] 分配的用 delete[] 释放，这里最根本的问题不是关于“析构函数”而是——内存泄漏。
实验代码：

int main()
{
int * pIntArray;
while (true)
{
pIntArray = new int[128];
delete pIntArray;
}
}

这样每次经过循环体，就会有 sizeof(int) * 127 的内存空间泄漏。

2、int double 这些基本类型，有“析构函数”吗？哈哈哈哈哈——

[abitz]

to Wolf0403(完美废人):
老兄最近去哪了？既然上网了也不和兄弟打个招呼，唉....
似乎对于基本类型，vc上用delete和delete[]是一样的，
不知别的编译器上也是这样吗？记得以前有个题目就是认为对
PODdelete和delete[]是等价的。
兄台这个例子在vs.net不会吃掉任何内存。
int main()
{
int * pIntArray;
while (true)
{
pIntArray = new int[1000];
delete pIntArray;
}
}

[xueweizhong]

1：
operator delete的确不调用析构函数

2：
编译器在处理表达式
delete p;
时将其分解成两个步骤：
p->~T();
operator delete((void*)p);

3:
》to Wolf0403(完美废人)
呵呵，兄弟的effective C++学得如何了？
不过这回是你错了，不要误了别人^^)。

[xiaocai365]

好像在那里看过，VC 中根本没有 delete[]
这也是 VC 的错，C++ 中有，最好别讨论什么什么编译器。

[xueweizhong]

》to Wolf0403(完美废人)
呵呵，是我没看清楚你们的细节讨论。
再看看....

[xiaocai365]

to xueweizhong(薛卫忠)

下面摘自《Effective C++》,哪里说operator delete的确不调用析构函数了？

=====================================================
条款5：对应的new和delete要采用相同的形式

下面的语句有什么错？


string *stringarray = new string[100];

...

delete stringarray;

一切好象都井然有序——一个new对应着一个delete——然而却隐藏着很大的错误：程序的运行情况将是不可预测的。至少，stringarray指向的100个string对象中的99个不会被正确地摧毁，因为他们的析构函数永远不会被调用。

用new的时候会发生两件事。首先，内存被分配(通过operator new 函数，详见条款7-10和条款m8)，然后，为被分配的内存调用一个或多个构造函数。用delete的时候，也有两件事发生：首先，为将被释放的内存调用一个或多个析构函数，然后，释放内存(通过operator delete 函数，详见条款8和m8)。对于 delete来说会有这样一个重要的问题：内存中有多少个对象要被删除？答案决定了将有多少个析构函数会被调用。

这个问题简单来说就是：要被删除的指针指向的是单个对象呢，还是对象数组？这只有你来告诉delete。如果你在用delete时没用括号，delete就会认为指向的是单个对象，否则，它就会认为指向的是一个数组：


string *stringptr1 = new string;
string *stringptr2 = new string[100];

...

delete stringptr1;// 删除一个对象
delete [] stringptr2;// 删除对象数组

如果你在stringptr1前加了"[]"会怎样呢？答案是：那将是不可预测的；如果你没在stringptr2前没加上"[]"又会怎样呢？答案也是：不可预测。而且对于象int这样的固定类型来说，结果也是不可预测的，即使这样的类型没有析构函数。所以，解决这类问题的规则很简单：如果你调用new时用了[]，调用delete时也要用[]。如果调用new时没有用[]，那调用delete时也不要用[]。

[xiaocai365]

to xueweizhong(薛卫忠)

你是说因为 int 没有 destructor，所以 operator delete 没有调用 destructor，
还是所有 operator delete 都不调用 destructor？

要是前者，那容易理解；要是后者，虚心求教，愿闻其详。

[xiaocai365]

to xueweizhong(薛卫忠)
我对内存管理的哪部分很生。
多谢，多谢，又学到东西了。

[laomai]

楼主的程序好象是从我这盗版的哦：-）
http://expert.csdn.net/Expert/topic/2590/2590333.xml?temp=.4470789

[aaassd]

是是是:)
就是没懂才来问的,不好意思了.

[Wolf0403]

那边的帖子最后讨论到一个话题：就是说 new/delete 最后都是 malloc/free 实现的，所以没问题。我觉得不能这样看这个问题。 C++ 既然设计了 new/delete 和 new[]/delete[] 分离的策略，就说明要写符合标准的代码就应该把它们良好配对，而不管特定编译器下它们都是如何实现的，有什么样的办法可以取巧。

[xueweizhong]

》 xiaocai365(小菜)
operator delete都不调用destructor。

我说过这个：
delete ptr;
等价于
ptr->~T(); // ------------------------#1
operator delete((void*)ptr);

如果T的dtor是trivial destructor,
那么#1将被优化掉。

注意这个两步骤分解是编译器做的。
这样做的目的是让operator delete(void*)的功能
只限于释放内存。

下面这个例子中使用了自定义的operator new和
operator delete,跑一下就有感觉了：

#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>

void* operator new(size_t len)
{
printf("operator new called(len = %d)\n", len);
return malloc(len);
}

void operator delete(void* ptr)
{
printf("operator delete(void*) called\n");
free(ptr);
}

struct Foo
{
Foo() { printf("ctor called\n"); }
~Foo() { printf("dtor called\n"); }
};

int main()
{
Foo* p = new Foo;
delete p;
}

[TyraelTiger]

operator delete 不能调用析构函数，delete operator才能够调用析构函数。在MoreEffectiveC++里面条款8有详细的说明。

[Jinhao]

operator delete不调用析构函数，只释放内存

[wangyangcheng]

Mark