delete []newobject;  
   是针对数组类型的变量的
  
————————————————————————————————————
写作，虽然每个人都会查阅辞海，可，不是人人都能写出不朽的篇章的。编程，如是也。

是不是还是这个

delete [](unsigned char *&)newobject;

delete []newobject; 
我的理解是 delete 时候传递 类型进去， 编译器会记忆首地址开始的那一段内存的长度， 因此也会知道那一段能存放几个对象， 然后在这些对象中依次调用析构函数， 然后再释放内存。

现在有一个问题是如果 p = new char[3]; delete []short;会出什么情况

class Y{
public:
int n;
Y(){cout << "Y" << endl;}
~Y(){cout << "~Y" << endl;}
};


int main(){
    Y *p = (Y*) new char[6]; 
    delete []p;
    return 0;
}

输出如下: 

~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
~Y
*** glibc detected *** ./ca: free(): invalid pointer: 0x0804a004 ***
======= Backtrace: =========
/lib/tls/i686/cmov/libc.so.6[0xb7d057cd]
/lib/tls/i686/cmov/libc.so.6(cfree+0x90)[0xb7d08e30]
/usr/lib/libstdc++.so.6(_ZdlPv+0x21)[0xb7ec6d11]
/usr/lib/libstdc++.so.6(_ZdaPv+0x1d)[0xb7ec6d6d]
./ca(__gxx_personality_v0+0x18e)[0x80487a6]
/lib/tls/i686/cmov/libc.so.6(__libc_start_main+0xdc)[0xb7cb3ebc]
./ca(__gxx_personality_v0+0x39)[0x8048651]
======= Memory map: ========
08048000-08049000 r-xp 00000000 03:0a 448366     /root/ca
08049000-0804a000 rw-p 00000000 03:0a 448366     /root/ca
0804a000-0806b000 rw-p 0804a000 00:00 0          [heap]
b7b00000-b7b21000 rw-p b7b00000 00:00 0 
b7b21000-b7c00000 ---p b7b21000 00:00 0 
b7c9d000-b7c9e000 rw-p b7c9d000 00:00 0 
b7c9e000-b7dd9000 r-xp 00000000 03:0a 608969     /lib/tls/i686/cmov/libc-2.5.so
b7dd9000-b7dda000 r--p 0013b000 03:0a 608969     /lib/tls/i686/cmov/libc-2.5.so
b7dda000-b7ddc000 rw-p 0013c000 03:0a 608969     /lib/tls/i686/cmov/libc-2.5.so
b7ddc000-b7ddf000 rw-p b7ddc000 00:00 0 
b7ddf000-b7dea000 r-xp 00000000 03:0a 576064     /lib/libgcc_s.so.1
b7dea000-b7deb000 rw-p 0000a000 03:0a 576064     /lib/libgcc_s.so.1
b7deb000-b7e10000 r-xp 00000000 03:0a 608977     /lib/tls/i686/cmov/libm-2.5.so
b7e10000-b7e12000 rw-p 00024000 03:0a 608977     /lib/tls/i686/cmov/libm-2.5.so
b7e12000-b7ef1000 r-xp 00000000 03:0c 129645     /usr/lib/libstdc++.so.6.0.8
b7ef1000-b7ef4000 r--p 000de000 03:0c 129645     /usr/lib/libstdc++.so.6.0.8
b7ef4000-b7ef6000 rw-p 000e1000 03:0c 129645     /usr/lib/libstdc++.so.6.0.8
b7ef6000-b7efd000 rw-p b7ef6000 00:00 0 
b7f07000-b7f09000 rw-p b7f07000 00:00 0 
b7f09000-b7f22000 r-xp 00000000 03:0a 576021     /lib/ld-2.5.so
b7f22000-b7f24000 rw-p 00019000 03:0a 576021     /lib/ld-2.5.so
bfe97000-bfeac000 rw-p bfe97000 00:00 0          [stack]
ffffe000-fffff000 r-xp 00000000 00:00 0          [vdso]
忽略

呵呵

居然 17个 ~Y, 

编译器估计管这种这种行为能叫故意捣蛋， 呵呵

Y *p = (Y*) new char[8]; 
 delete []p;

也不行， 那就是我说错了， 编译器不看首地址而推断有几个对象该被析构

让我试试找找其中原因.
我们知道delete[]要作两件事情: (1)对数组中每一个元素调用析构函数. (2)用operator 
delete[]()释放对象数组所占内存. 一个有趣的问题是,给delete[]的参数只是一个对象
指针,它如何知道其中到底有多少个元素(以便挨个析构)? C++标准对此没有规定,编译器
需自己想办法得到元素个数. 常见的作法(好象VC就是这样)是在第一个元素之前某个地方
存放元素个数. 注意这样一来new []所申请内存并不是简单的元素size的n倍,在它前面还
有个"前缀".在operator delete[]释放内存时,需要考虑这个"前缀"的存在. 大家都知道,
释放一个错误的地址会导致不可预料结果.
现在的问题是,这个"前缀"的格式和大小并不是固定的,而与new[]对象的类型有关. 注意
newobject是以char数组申请,而以my_t数组释放. 因此会有如下两个问题:
 (1)得不到准确元素个数
 (2)计算需释放内存起始地址错误,引发异常

见的作法(好象VC就是这样)是在第一个元素之前某个地方
存放元素个数

这句话是有问题的， 比如

void* p = malloc(8);
new (p) Y[2];

该怎么办呢？ p 之前是有内容， 但其应该就是 以 p 为首地址到空间结束这一段的字节数， 也就是8在本例

哦， 上面那个有办法解决， 换一个：

void* p = malloc(8);
new (&p[1]) Y;

这个就很有说服力了

靠， 应该是

void* p = malloc(8);
new ((char*) (p) + 4) Y;

对不起,我没说清楚.
"前缀"的情况我说的是指用new []申请的内存,malloc当然不在此例
而且当申请的对象没有析构函数时(例如new char[])也不一定有前缀.
对这种问题感兴趣时最好的手段是用查看汇编代码.

嘿嘿， 汇编咱家不懂， 不过若是这样
那么  p = new Y[2]; delete p; 只能对第一个 Y 调用  ~Y（）就有点说不过去了， 你知道从那里开始的有几个， 干嘛只调用一个,鬼知道写编译器的和订c++标准的怎么想的。

我觉得是从效率考虑吧.delete就不用查看前缀了.这也是C++定义delete和delete[]两种方式的原因.

btw, 可能正因为如此,C++一再警告delete与delete[]不可混用. 因为有前缀的存在,错用的结果不只是漏掉析构函数,更严重的是可能引发异常.

补充: 其实还不只是效率的问题.因为我们有个前提:非数组对象如Y*p = new Y;是没有前缀的(否则代价太大了,因为很多情况是new单个对象而不是数组). 这样,在你传给delete一个指针时,它没法知道指针前面的一段是不是数组前缀.

去看《Effective C++ 》2e item 5

taodm, 给你提个建议, 要是知道直接说出来,拐弯抹角的不痛快

太长，帖起来太累。

最终还是没有很好的确定 使用那种方式释放啊。。

delete [](unsigned char)newobject;
我想还可以这样。。。,但是没有理论依据

支持taodm和deng2000() 
看《Effective C++》

经过在 VC 中测试

delete [](const *&)newobject 内存不会泄漏，但是它是按一个一个字节删除释放的非常慢、 


delete []newobject 和 delete newobject 都没有内存泄漏，很是郁闷，是不是 VC 优化了

看不懂汇编代码，很是失望，那位解释一下..

建议: 你给my_t加上分析构函数再试试:

class my_t
{
...
~my_t(){};
}

应hzhxxx的需求,也为满足自己的好奇心,我在VS2003中试图用下面的简单例子分析delete[]的汇编代码:
A* p = new A[6];
delete [] p;
先分析没有析构函数的情况, 如下定义A:
class A
{
public:
    A(){m=0; n=0;};
public:
int m;
int n;
};

delete[]p对应的汇编代码如下:

delete [] p;
00411DEC  mov         eax,dword ptr [p] 
00411DEF  mov         dword ptr [ebp-0E0h],eax 
00411DF5  mov         ecx,dword ptr [ebp-0E0h] 
00411DFB  push        ecx  
00411DFC  call        operator delete[] (4110B4h) 
00411E01  add         esp,4 

我们可以看到,此时delete[]p的代码很简单,就是简单以数组的首地址p(也就是ecx)为参数调用operator delete[]释放内存(注意delete[]和operator delete[]是两码事!).插一句题外话,我进一步跟到operator delete[]内后发现它其实就是简单地调用operator delete而已.

而当我给A加上析构函数:
class A
{
public:
    A(){m=0; n=0;};
    ~A() {};
public:
    int m;
    int n;
};
虽然~A()里面什么也没干,delete[]p已变得大不一样了:

delete [] p;
00411E03  mov         eax,dword ptr [p] 
00411E06  mov         dword ptr [ebp-0E0h],eax 
00411E0C  mov         ecx,dword ptr [ebp-0E0h] 
00411E12  mov         dword ptr [ebp-0ECh],ecx 
00411E18  cmp         dword ptr [ebp-0ECh],0 
00411E1F  je          main+0E6h (411E36h) 
00411E21  push        3    
00411E23  mov         ecx,dword ptr [ebp-0ECh] 
00411E29  call        A::`vector deleting destructor' (4116A9h) 
00411E2E  mov         dword ptr [ebp-10Ch],eax 
00411E34  jmp         main+0F0h (411E40h) 
00411E36  mov         dword ptr [ebp-10Ch],0 

不再是简单地调用operator delete[]了事,而是调用A::`vector deleting destructor'.从名字就可看出是要多次析构了(其实还包括释放内存). A::`vector deleting destructor'的代码比较长,下面这一段是其中我们感兴趣的部分:

////////// part of A::`vector deleting destructor'
004131D0  mov         eax,dword ptr [this] 
004131D3  mov         ecx,dword ptr [eax-4] 
004131D6  push        ecx  
004131D7  push        8    
004131D9  mov         edx,dword ptr [this] 
004131DC  push        edx  
004131DD  call        `eh vector destructor iterator' (4116BDh) 
004131E2  mov         eax,dword ptr [ebp+8] 
004131E5  and         eax,1 
004131E8  je          A::`vector deleting destructor'+59h (4131F9h) 
004131EA  mov         eax,dword ptr [this] 
004131ED  sub         eax,4 
004131F0  push        eax  
004131F1  call        operator delete[] (4110B4h)

首先注意这一句: 
004131D3  mov         ecx,dword ptr [eax-4]
eax是p地址,它把p前面4字节作为一个整数赋给ecx. Aha! 这就是传说中的"前缀"了.而且比我想象的还简单,没有什么复杂结构,就是一个整数记录元素个数.此时查看ecx的值确实是6,即数组中有6个元素.

再注意这一句:  
004131D7  push        8
这个8就是sizeof(A) (A中有两个整数成员m和n).

再看这一句:
004131DD  call        `eh vector destructor iterator' (4116BDh)
我们可以看到push给它的三个参数(ecx, 8, edx)分别是数组元素个数,元素size和数组地址.你应该能猜出`eh vector destructor iterator'要干什么吧? 对,就是对每个元素调用析构函数~A().篇幅所限,我就不列出其执行的详细过程了.

最后,看看这几行:
004131EA  mov         eax,dword ptr [this] 
004131ED  sub         eax,4 
004131F0  push        eax  
004131F1  call        operator delete[] (4110B4h)
还是调用operator delete[]释放内存,但注意传给它的参数不是数组地址,而是数组地址往前4字节.跟我们预测的一样,释放内存时考虑了前缀的存在.

经过这些分析我们可得到初步结论如下:
1. 前缀是否存在取决于有没有显式析构函数.
2. 前缀就是4字节整型,记录元素个数.

再次重申,这里分析的是用new []得到的对象数组.而且只是对VS2003的一个简单例子分析.对象更复杂一点时前缀有可能发生变化(虽然我觉得可能性不大).其它编译器就更不知道了.

有了这些分析,再回头看hzhxxx的疑问
delete []newobject 和 delete newobject都没有内存泄漏是因为my_t没有显式析构函数.当你加上~my_t()后,就不只是内存泄漏的问题了,而是会导致内存异常错.因为你释放时的地址参数与申请时的地址参数相差4字节.

typedef struct my_t
{
int m_a;
char m_y[1024];
static int m_count;
my_t()
{
m_a = 0;
memset(m_y,0,sizeof(m_y));
}

~my_t()
{
m_count++;
std::cout<<m_count<<endl;
}
};
int my_t::m_count = 0;

这样增加一个析构函数，相反，使用 delete[] newobject; 运行的时候报错；
但是如果使用 delete newobject 虽然能正确运行，但是明显析构的对象是一个，存在
内存泄漏，但是我测试创建很多对象，也没有发现内存泄漏

有点难于理解

--------------------------------------------------------------------------------
 

条款10: 如果写了operator new就要同时写operator delete

让我们回过头去看看这样一个基本问题：为什么有必要写自己的operator new和operator delete？

答案通常是：为了效率。缺省的operator new和operator delete具有非常好的通用性，它的这种灵活性也使得在某些特定的场合下，可以进一步改善它的性能。尤其在那些需要动态分配大量的但很小的对象的应用程序里，情况更是如此。

例如有这样一个表示飞机的类：类airplane只包含一个指针，它指向的是飞机对象的实际描述(此技术在条款34进行说明)：

class airplanerep { ... };      // 表示一个飞机对象
                                // 
class airplane {
public:
  ...
private:
  airplanerep *rep;             // 指向实际描述
};

一个airplane对象并不大，它只包含一个指针（正如条款14和m24所说明的，如果airplane类声明了虚函数，会隐式包含第二个指针）。但当调用operator new来分配一个airplane对象时，得到的内存可能要比存储这个指针（或一对指针）所需要的要多。之所以会产生这种看起来很奇怪的行为，在于operator new和operator delete之间需要互相传递信息。

因为缺省版本的operator new是一种通用型的内存分配器，它必须可以分配任意大小的内存块。同样，operator delete也要可以释放任意大小的内存块。operator delete想弄清它要释放的内存有多大，就必须知道当初operator new分配的内存有多大。有一种常用的方法可以让operator new来告诉operator delete当初分配的内存大小是多少，就是在它所返回的内存里预先附带一些额外信息，用来指明被分配的内存块的大小。也就是说，当你写了下面的语句，

airplane *pa = new airplane;

你不会得到一块看起来象这样的内存块：

    pa——> airplane对象的内存

而是得到象这样的内存块：

    pa——> 内存块大小数据 + airplane对象的内存

对于象airplane这样很小的对象来说，这些额外的数据信息会使得动态分配对象时所需要的的内存的大小翻番（特别是类里没有虚拟函数的时候）。

如果软件运行在一个内存很宝贵的环境中，就承受不起这种奢侈的内存分配方案了。为airplane类专门写一个operator new，就可以利用每个airplane的大小都相等的特点，不必在每个分配的内存块上加上附带信息了。

具体来说，有这样一个方法来实现你的自定义的operator new：先让缺省operator new分配一些大块的原始内存，每块的大小都足以容纳很多个airplane对象。airplane对象的内存块就取自这些大的内存块。当前没被使用的内存块被组织成链表——称为自由链表——以备未来airplane使用。听起来好象每个对象都要承担一个next域的开销（用于支持链表），但不会：rep域的空间也被用来存储next指针（因为只是作为airplane对象来使用的内存块才需要rep指针；同样，只有没作为airplane对象使用的内存块才需要next指针），这可以用union来实现。

具体实现时，就要修改airplane的定义，从而支持自定义的内存管理。可以这么做：

class airplane {           // 修改后的类 — 支持自定义的内存管理
public:                    // 

  static void * operator new(size_t size);

  ...

private:
  union {
    airplanerep *rep;      // 用于被使用的对象
    airplane *next;        // 用于没被使用的（在自由链表中）对象
  };

  // 类的常量，指定一个大的内存块中放多少个
  // airplane对象，在后面初始化
  static const int block_size;

  static airplane *headoffreelist;

};

上面的代码增加了的几个声明：一个operator new函数，一个联合（使得rep和next域占用同样的空间），一个常量（指定大内存块的大小），一个静态指针（跟踪自由链表的表头）。表头指针声明为静态成员很重要，因为整个类只有一个自由链表，而不是每个airplane对象都有。

下面该写operator new函数了：

void * airplane::operator new(size_t size)

{
  // 把“错误”大小的请求转给::operator new()处理;
  // 详见条款8
  if (size != sizeof(airplane))
    return ::operator new(size);

  airplane *p =           // p指向自由链表的表头 
    headoffreelist;       // 

  // p 若合法，则将表头移动到它的下一个元素
  // 
  if (p)
    headoffreelist = p->next;

  else {
    // 自由链表为空，则分配一个大的内存块，
    // 可以容纳block_size个airplane对象
    airplane *newblock =
      static_cast<airplane*>(::operator new(block_size *
                                            sizeof(airplane)));

    // 将每个小内存块链接起来形成一个新的自由链表
    // 跳过第0个元素，因为它要被返回给operator new的调用者
    // 
    for (int i = 1; i < block_size-1; ++i)
      newblock[i].next = &newblock[i+1];

    // 用空指针结束链表
    newblock[block_size-1].next = 0;

    // p 设为表的头部，headoffreelist指向的
    // 内存块紧跟其后
    p = newblock;
    headoffreelist = &newblock[1];
  }

  return p;
}

如果你读了条款8，就会知道在operator new不能满足内存分配请求时，会执行一系列与new-handler函数和例外有关的例行性动作。上面的代码没有这些步骤，这是因为operator new管理的内存都是从::operator new分配来的。这意味着只有::operator new失败时，operator new才会失败。而如果::operator new失败，它会去执行new-handler的动作（可能最后以抛出异常结束），所以不需要airplane的operator new也去处理。换句话说，其实new-handler的动作都还在，你只是没看见，它隐藏在::operator new里。

有了operator new，下面要做的就是给出airplane的静态数据成员的定义：

airplane *airplane::headoffreelist;      
                                         
const int airplane::block_size = 512;

看不懂 楼主表述清楚点吧 谢谢啦

From hzhxxx:
这样增加一个析构函数，相反，使用 delete[] newobject; 运行的时候报错；
但是如果使用 delete newobject 虽然能正确运行，但是明显析构的对象是一个，存在
内存泄漏，但是我测试创建很多对象，也没有发现内存泄漏.

============================================================

提醒楼主: delete和delete[]都是按顺序作两件事情:
1). 为(一个或多个)对象调用析构函数.
2). 释放对象所占内存.
要分清楚这两步是干完全不同的事情.即析构函数!=释放内存.因为你的~my_t()没干什么实际事情,即使漏调用或多调用了也没有什么大问题.真正导致你的例子中种种问题的是第2步
要使第2步正确执行,需要保证你释放的地址确实是当初申请时的地址.而正如我前面指出的,在某种特定情况下,二者相差4字节导致异常.

感谢 

deng2000() ( ) 信誉：100    

这么晚了还坚持发帖，，，

但是还是无法确定使用那种释放内存的方式。。

就你这个程序而言,以下面方式释放是最稳妥的,不管my_t有没有显式析构函数.

newobject->~my_t();
(newobject+1)->~my_t();
delete [] (unsigned char *)newobject;

假如我创建 N 个 newobject ，那不是要循环释放啊

//assign((unsigned char *&)newobject,sizeof(my_t) * N);

for(unsigned int i = 0 ;i < N;++i)
{
    (newobject + i)->m~y_t();
}
delete [](unsigned char *)newobject;

这种方式可能不合适吧，有点怪异啊。。。

能加 qq 吗，私下讨论一下

今天看了 more effective c++,综合上面的分析
感觉这样可能比较合适,也是比较通用的释放方法

假如我创建 N 个 newobject ，那不是要循环释放啊
//assign((unsigned char *&)newobject,sizeof(my_t) * N);

for(unsigned int i = 0 ;i < N;++i)
{
    (newobject + i)->m~y_t();
}
operator delete [](newobject);
首先依次调用每个对象的析构函数，再调用全局的
operator delete[](void *memoryToBeDeallocated)
函数释放被分配的内存,就是这样比较慢.