从汇编看c++的new和delete

下面是c++源码:

class X {

private:

    int _x;

public:

    X(int xx = ) : _x(xx) {}

    ~X() {}

};

int main() {

    X* xp = new X;

    delete xp;

}

代码很简单，在main函数里面先用new构造一个堆对象，然后用delelte释放此对象。

接下来看构造堆对象的汇编码:

  :     X* xp = new X;

    push    ;压入对象的大小4byte，为调用operator new函数传递参数

    call    ??@YAPAXI@Z                ; 调用operator new函数

    add    esp, ;operator new调用结束，堆栈指针下移4byte，释放为operator new的参数分配的栈空间

    mov    DWORD PTR $T2579[ebp], eax;寄存器eax里面存放申请到的堆空间首地址,存入临时变量ST2579

    cmp    DWORD PTR $T2579[ebp], ;将临时变量ST2579的值与0比较，即检测申请的对空间首地址是否为NULL

    je    SHORT $LN3@main;如果检测结果相等，就跳转到标号$LN3@main处执行，否则顺序执行。这里是顺序执行

    push    ;将0压栈，为调用构造函数传递参数

    mov    ecx, DWORD PTR $T2579[ebp];将临时变量ST2579的值(里面保存申请到的堆空间首地址)给寄存器ecx，作为隐含参数传递给构造函数

                                  ;这个隐含参数就是this指针

    call    ??0X@@QAE@H@Z                ; 调用对象的构造函数

    mov    DWORD PTR tv70[ebp], eax;构造函数调用完毕，寄存器eax里面存放的是对象首地址，这里将首地址给临时变量tv70

    jmp    SHORT $LN4@main;跳转到标号$LN4@main处执行

$LN3@main:

    mov    DWORD PTR tv70[ebp], ;如果申请对空间失败，将0给临时变量tv70

$LN4@main:

    mov    eax, DWORD PTR tv70[ebp];将tv70的值给寄存器eax

    mov    DWORD PTR _xp$[ebp], eax;将寄存器eax的值给指针变量xp

从汇编码可以看到，用new构造堆对象时，大致的流程是:

1 调用operator new申请堆空间

2 对申请到的堆空间首地址进行检查，防止申请失败，返回空指针

3 如果申请堆空间成功，就调用构造函数并将堆空间首地址给xp指针。

因此，c++中用new申请堆空间与用malloc不同，前者自动检测堆空间是否申请成功。

下面看析构堆对象的汇编码:

 :     delete xp;

    mov    ecx, DWORD PTR _xp$[ebp];将xp指针的值(即堆对象首地址)给寄存器ecx

    mov    DWORD PTR $T2591[ebp], ecx;将ecx的值给临时变量ST2591

    mov    edx, DWORD PTR $T2591[ebp];将临时变量ST2591的值给寄存器edx

    mov    DWORD PTR $T2590[ebp], edx;将寄存器edx里面的值给临时变量ST2590

    cmp    DWORD PTR $T2590[ebp], ;将临时变量ST2590的值与0比较，即检测传进来的堆对象首地址是否为空指针

    je    SHORT $LN5@main;如果为空指针，则跳转到标号$LN5@main处执行，否则，顺序执行。这里顺序执行

    push    ;压入对象类型标志 1 单个对象 3 对象数组  0 只调用析构函数，不调用释放堆空间(在多重继承时有用)
    mov    ecx, DWORD PTR $T2590[ebp];将临时变量ST2590的值给寄存器ecx，作为隐函数参数(this指针)传递给析构代理函数

    call    ??_GX@@QAEPAXI@Z;调用析构代理函数

    mov    DWORD PTR tv75[ebp], eax;析构代理函数执行完毕，寄存器eax里面保存堆对象首地址，将eax的值给临时变量tv75

    jmp    SHORT $LN1@main;跳转到标号$LN1@main处执行

$LN5@main:

    mov    DWORD PTR tv75[ebp], ;如果检测堆对象首地址失败，临时变量tv75的值赋0

$LN1@main:;标号后面是main函数结束时的代码

从汇编码可以看到，调用delete并不像operator new一样直接调用析构函数和operator delete函数，而是调用了析构代理函数来完成operator delete的功能。之所以要用代理函数，是因为某些情况下要释放的对象不止一个。

下面是析构代理函数汇编码:

??_GX@@QAEPAXI@Z PROC                    ; X::`scalar deleting destructor', COMDAT

; _this$ = ecx

    push    ebp

    mov    ebp, esp

    push    ecx;寄存器ecx里面存储的是对对象首地址，这里压栈的目的是为了保存这个地址预留空间

    mov    DWORD PTR _this$[ebp], ecx;将ecx里面的值存到刚才预留的空间里面

    mov    ecx, DWORD PTR _this$[ebp];将堆对象首地址给寄存器ecx，作为隐含参数传递给析构函数

    call    ??1X@@QAE@XZ                ; 调用析构函数

    mov    eax, DWORD PTR ___flags$[ebp];这里获取在调用析构代理函数之前，传进来的标志，并将其给寄存器eax

    and    eax, ;将eax里面(对象类型标志)的值与1相与 目的是判断是否调用delete函数释放堆空间
    je    SHORT $LN1@scalar;如果相与的结果为0，则跳到标号$LN1@scalar处执行，否则，顺序执行，这里顺序执行

    mov    ecx, DWORD PTR _this$[ebp];将堆对象首地址作为给寄存器ecx

    push    ecx;压栈ecx的值，为调用delete函数传递参数

    call    ??@YAXPAX@Z                ; 调用delete函数

    add    esp, ;delete函数调用完毕，栈顶指针下移4byte，释放为delete函数的参数分配的栈空间

$LN1@scalar:

    mov    eax, DWORD PTR _this$[ebp];将堆对象首地址给寄存器eax
                                     ;做为返回值
    mov    esp, ebp

    pop    ebp

    ret

??_GX@@QAEPAXI@Z ENDP

从汇编码可以看到，析构代理函数先调用真正的析构函数，然后再调用delete函数释放申请到的堆空间。在这中间有一个判断过程，即通过对象类型标志，判断是否调用operator delete释放堆空间。

通过上面的汇编码，可以看到delete的流程大致是:

1 检测对象首地址值是否为空

2 如果不为空，就调用析构代理函数，否则，就不调用析构代理函数

3 在析构代理函数里面调用对象的析构函数和delete函数(如果对象标志不为0的话)

从对c++中的delete调用过程来看，delete不会自动的将指针变量xp的值清零。因此，后续程序中如果使用xp指针仍然可行。指针变量xp和xp所指向的对象，最大的差别就是哪一个声明已经结束了。调用delete后，xp所指向的对象已将被析构，变得不合法，但是地址本身仍然代表一个合法的程序空间。

对象数组

下面来看new和delete应用于对象数组的情况

c++源码如下:

class X {

private:

    int _x;

public:

    X(int xx = ) : _x(xx) {}

    ~X() {}

};

int main() {

    X* xp = new X[];

    delete [] xp;

}

上述代码在用new在堆中构造了2个对象，然后通过delete释放。

下面里看构造过程汇编码:

   X* xp = new X[];

00F035BD  push        0Ch ;为调用operator new运算符传递参数，即要申请的堆空间的大小

                          ;这里每个对象只有4byte，但是却要申请12byte，是因为对于申请数组对象

                          ;堆空间首地址4byte用来存储对象个数

00F035BF  call        operator new ;调用operator new运算符

00F035C4  add         esp, ;operator new调用结束，栈顶指针下移4byte，释放为operator new传递参数而分配的栈空间

00F035C7  mov         dword ptr [ebp-0F8h],eax;寄存器eax里面保存了申请到的堆空间首地址

00F035CD  mov         dword ptr [ebp-],  ;

00F035D4  cmp         dword ptr [ebp-0F8h],  ;将返回的堆空间首地址与0比较，检测是否申请成功

00F035DB  je          main+97h (0F03617h)  ;如果申请不成功，即返回NULL，则跳到地址0F03617h处执行 否则，顺序执行 这里顺序执行

00F035DD  mov         eax,dword ptr [ebp-0F8h]  ;将堆空间首地址给寄存器eax

00F035E3  mov         dword ptr [eax],  ;将2写入堆空间首地址所在内存，即在堆空间首地址4byte处保存对象个数

00F035E9  push        offset X::~X (0F011DBh) ;将析构函数地址压栈，作为构造代理函数参数

00F035EE  push        offset X::`default constructor closure' ;将构造函数地址压栈，作为构造代理函数参数

00F035F3  push        2  ;将对象个数压栈，作为构造代理函数参数

00F035F5  push        4  ;将对象大小压栈，作为构造代理函数参数

00F035F7  mov         ecx,dword ptr [ebp-0F8h] ;将堆空间首地址给寄存器ecx

00F035FD  add         ecx,4  ;ecx里面的值加4 即跳过堆空间首地址4byte，此时ecx里面保存的是第一个堆对象首地址

00F03600  push        ecx  ;压栈ecx，作为构造代理函数参数

00F03601  call        `eh vector constructor iterator' (0F011E5h)  ;调用构造代理函数

00F03606  mov         edx,dword ptr [ebp-0F8h]  ;将堆空间首地址给寄存器edx

00F0360C  add         edx,  ;edx里面的值加4 即跳过堆空间首地址4byte，此时edx里面保存的是第一个堆对象首地址

00F0360F  mov         dword ptr [ebp-10Ch],edx

00F03615  jmp         main+0A1h (0F03621h)  ;跳到地址0F03621h处执行

00F03617  mov         dword ptr [ebp-10Ch],  ;如果堆空间申请失败，赋空指针

00F03621  mov         eax,dword ptr [ebp-10Ch]

00F03627  mov         dword ptr [ebp-104h],eax

00F0362D  mov         dword ptr [ebp-],0FFFFFFFFh

00F03634  mov         ecx,dword ptr [ebp-104h]

00F0363A  mov         dword ptr [ebp-14h],ecx  ;堆空间中第一个堆对象首地址给了xp

上面的汇编码流程大致是:

1 调用operator new分配堆空间

2 调用构造代理函数构造堆对象，在调用构造代理函数时，通过压栈，像其传递了5个参数，分别是 a)第一个堆对象首地址 b)堆对象大小

c)堆对象个数 d)构造函数地址 e)析构函数地址

3 传回第一个堆对象首地址，而不是申请到的堆空间首地址

从上面汇编码中还可以看到，申请到的堆空间首地址用来存放的是对象的个数，因此，堆空间总大小并不是对象大小 * 对象个数

下面是构造代理函数的汇编码，只看相关部分:

00F03792  mov         dword ptr [ebp-20h],

00F03799  mov         dword ptr [ebp-],

00F037A0  mov         dword ptr [ebp-1Ch],  ;将该内存的值初始化为0 相当于for循环中，循环变量初始化为0

00F037A7  jmp         `eh vector constructor iterator'+52h (0F037B2h)  ;跳转到地址0F037B2h处执行

00F037A9  mov         eax,dword ptr [ebp-1Ch]  ;循环变量的值给寄存器eax

00F037AC  add         eax,1  ;寄存器eax里面的值加1，即循环变量加1

00F037AF  mov         dword ptr [ebp-1Ch],eax  ;将循环变量保存到内存中

00F037B2  mov         ecx,dword ptr [ebp-1Ch] ;循环变量值给了寄存器ecx

00F037B5  cmp         ecx,dword ptr [ebp+10h];将ecx里面的值和 dword ptr [ebp+10h]内存所代表的值(对象个数2)比较，相当于循环变量的比较

00F037B8  jge         `eh vector constructor iterator'+6Bh (0F037CBh)  ；如果循环变量的值大于等于2，就跳转到地址0F037CBh执行，否则顺序执行

00F037BA  mov         ecx,dword ptr [ebp+]  ;将第一个堆对象对象首地址给寄存器ecx，作为隐含参数给构造函数

00F037BD  call        dword ptr [ebp+14h] ;调用构造函数

00F037C0  mov         edx,dword ptr [ebp+]  ;将第一个堆对象首地址给寄存器edx

00F037C3  add         edx,dword ptr [ebp+0Ch] ;edx里面的值加上对象大小，即修改指针，指向下一个堆对象首地址

00F037C6  mov         dword ptr [ebp+],edx ;堆对象首地址首地址保存到内存中

00F037C9  jmp         `eh vector constructor iterator'+49h (0F037A9h);调转到地址0F037A9h处执行

;======================下面还有代码，但是是完成构造函数之后，因此省略========================

构造代理函数的作用就是循环调用构造函数，依次构造数组中的每一对象

下面是释放数组对象的汇编码:

delete [] xp;

00A2363D  mov         eax,dword ptr [ebp-14h];将堆空间中第一个对象首地址给寄存器eax

                                             ;接下来是对eax的值的传递过程

00A23640  mov         dword ptr [ebp-0E0h],eax

00A23646  mov         ecx,dword ptr [ebp-0E0h]

00A2364C  mov         dword ptr [ebp-0ECh],ecx  ;最后eax的值(即堆空间第一个对象首地址)给了ebp-0ECh所在内存

00A23652  cmp         dword ptr [ebp-0ECh],  ;检测该内存里面的值是否为空

00A23659  je          main+0F0h (0A23670h) ;如果为空，跳到地址0A23670h处执行，否则，顺序执行 这里是顺序执行

00A2365B  push          ;压入释放对象类型标志，1为单个对象，3为释放对象数组，0仅表示执行析构函数，不释放堆空间

                         ;压入的值将作为参数传递给析构代理函数

00A2365D  mov         ecx,dword ptr [ebp-0ECh]  ;将堆空间中第一个对象首地址给寄存器ecx，作为隐含参数传递给析构代理函数

00A23663  call        X::`vector deleting destructor' (0A211EAh)  ;调用vector deleting destructor函数
00A23668  mov         dword ptr [ebp-10Ch],eax

00A2366E  jmp         main+0FAh (0A2367Ah)

00A23670  mov         dword ptr [ebp-10Ch],0

    13:

    14: }

vector deleting destructor函数的汇编码:

X::`vector deleting destructor':

00A21B10  push        ebp

00A21B11  mov         ebp,esp

00A21B13  sub         esp,0CCh

00A21B19  push        ebx

00A21B1A  push        esi

00A21B1B  push        edi

00A21B1C  push        ecx  ;在调用该函数之前，ecx寄存器保存的是堆空间中，第一个对象的首地址

                           ;这里将首地址压入栈中保存，因为下面的代码中将用到寄存器ecx

00A21B1D  lea         edi,[ebp-0CCh]

00A21B23  mov         ecx,33h

00A21B28  mov         eax,0CCCCCCCCh

00A21B2D  rep stos    dword ptr es:[edi]

;==========================================以上代码为函数入口部分====================

00A21B2F  pop         ecx  ;将栈顶里面的值(保存着堆空间中第一个对象首地址)弹出，存到寄存器ecx，

00A21B30  mov         dword ptr [ebp-8],ecx  ;将对象首地址存放到ebp-8所代表的内存

00A21B33  mov         eax,dword ptr [ebp+8]  ;对象类型标标志被保存在了寄存器eax中

00A21B36  and         eax,2  ;将eax里面的值和2相与，检测是否为对象数组标志(因为标志只能为0 1 3，如果不为3 结果肯定为0)

00A21B39  je          X::`vector deleting destructor'+61h (0A21B71h);如果结果为0，即不是对象数组标志

                                                                    ;跳转到地址0A21B71h处执行 否则 顺序执行 这里顺序执行

00A21B3B  push        offset X::~X (0A211DBh);将析构函数的地址压栈，作为参数传递给析构代理函数

00A21B40  mov         eax,dword ptr [this] ;this指针指向堆空间中第一个对象首地址，这里将该值给寄存器eax

00A21B43  mov         ecx,dword ptr [eax-]  ;将向上偏移堆空间中第一个对象首地址4byte处内存内容(即申请到的堆空间首地址处

                                             ;内存内容，该内存里面保存着对象个数)给寄存器ecx

00A21B46  push        ecx  ;将ecx压栈，作为参数传递给析构代理函数

00A21B47  push          ;将对象大小压栈，作为参数传递给析构代理函数

00A21B49  mov         edx,dword ptr [this]  ;将堆空间中第一个对象首地址给寄存器edx

00A21B4C  push        edx ;将edx的值压栈，作为参数传递给析构代理函数

00A21B4D  call        `eh vector destructor iterator' (0A211F4h) ;调用析构代理函数

00A21B52  mov         eax,dword ptr [ebp+8]  ;获取对象类型标志，其值在调用该函数之前被压入栈中

00A21B55  and         eax,1;将寄存器eax的值和1相与，目的是判断是否要调用delete函数释放堆空间

00A21B58  je          X::`vector deleting destructor'+59h (0A21B69h)  ;如果相与结果为0，就跳转到地址0A21B69h处执行，否则

                                                                      ;顺序执行，这里顺序执行

00A21B5A  mov         eax,dword ptr [this]  ;将堆空间中第一个对象首地址给寄存器eax

00A21B5D  sub         eax,  ;将eax里面的值减4，即修正了eax里面的值，此时，eax里面保存的是申请到的堆空间首地址

00A21B60  push        eax  ;将eax的值压栈，作为隐含参数传递给operator delete

00A21B61  call        operator delete (0A21087h) ;调用operator delete，释放堆空间

00A21B66  add         esp,  ;调用operator delete结束，释放为其传参时的栈空间

00A21B69  mov         eax,dword ptr [this];将堆空间中第一个对象首地址给寄存器eax

00A21B6C  sub         eax,  ;将eax的值减4，即修正eax里面的值，此时，eax里面存储的是申请到的堆空间首地址

00A21B6F  jmp         X::`vector deleting destructor'+80h (0A21B90h)  ;跳转到地址0A21B90h处执行

;=====================下面代码是传进来的对象标志不是3时执行的代码=====================

00A21B71  mov         ecx,dword ptr [this] ;如果对象标志不是3，将跳转到这里执行。将堆空间中对象首地址给寄存器ecx，作为隐含参数调用析构函数

00A21B74  call        X::~X (0A211DBh)  ;调用析构函数

00A21B79  mov         eax,dword ptr [ebp+8] ;将对象类型标志给寄存器eax

00A21B7C  and         eax,1  ;和上面一样，判断是否释放堆空间

00A21B7F  je          X::`vector deleting destructor'+7Dh (0A21B8Dh)  ;如果对象标志为0，就跳转到地址0A21B8Dh处执行

                                                                      ;否则，顺序执行

00A21B81  mov         eax,dword ptr [this]  ;将堆对象首地址给寄存器eax

00A21B84  push        eax  ;压入eax，作为operator delete的参数

00A21B85  call        operator delete (0A21087h)  ;调用operator delete

00A21B8A  add         esp,  ;operator delete调用结束，释放为其传递参数分配的栈空间

00A21B8D  mov         eax,dword ptr [this] ;将堆对象首地址给寄存器eax，作为返回值

00A21B90  pop         edi

00A21B91  pop         esi

00A21B92  pop         ebx

00A21B93  add         esp,0CCh

00A21B99  cmp         ebp,esp

00A21B9B  call        @ILT+(__RTC_CheckEsp) (0A21136h)

00A21BA0  mov         esp,ebp

00A21BA2  pop         ebp

00A21BA3  ret

vector deleting destructor总体流程也是先调用析构代理函数，然后调用operator delete释放空间(如果对象标志不为0的话),并且在调用析构代理函数时也传进4个参数 a)堆空间中第一个对象首地址 b)对象大小 c)对象个数 d)虚函数地址

下面是析构代理函数的汇编码:

mov         ecx,dword ptr [ebp+0Ch]  ;获取堆对象个数，给寄存器ecx

00A236E0  imul        ecx,dword ptr [ebp+10h]  ;ebp+10h所代表的内存里面存放对象大小，这条指令将ecx的值和ebp+10h

                                               ;的值相乘，将结果保存在ecx里面

                                               ;ecx里面此时保存的是所有堆对象所占大小

00A236E4  add         ecx,dword ptr [ebp+]  ;ebp+8所代表的的内存存放堆空间中第一个对象首地址，这里将它与ecx相加

                                             ;结果保存在ecx里面，此时ecx存放的是堆空间中最后一个对象后面的内存地址

                                             ;这么做是为了从最后一个对象开始析构

00A236E7  mov         dword ptr [ebp+],ecx  ;将ecx的值保存到ebp+8所代表的内存

00A236EA  mov         dword ptr [ebp-],

00A236F1  mov         edx,dword ptr [ebp+10h]  ;将对象个数给寄存器edx，相当于for循环里面的循环技术变量

00A236F4  sub         edx,  ;edx里面的值减1

00A236F7  mov         dword ptr [ebp+10h],edx ;将edx里面的值存放到ebp+10h所代表的的内存

00A236FA  js          `eh vector destructor iterator'+6Dh (0A2370Dh) ;如果edx-1时为父，跳转到地址0A2370Dh处执行

00A236FC  mov         eax,dword ptr [ebp+8] ;将ebp+8内存的值(即最后一个堆对象后面的内存地址)给寄存器eax

00A236FF  sub         eax,dword ptr [ebp+0Ch]  ;ebp+0ch所代表的内存存放对象大小，这里用eax-对象大小

                                               ;这里依次得到从最后一个堆对象到第一个堆对象首地址，

                                               ;存放到寄存器eax

00A23702  mov         dword ptr [ebp+8],eax;将eax的值保存到ebp+8所代表的内存

00A23705  mov         ecx,dword ptr [ebp+8];将堆对象首地址给ecx寄存器，作为隐含参数传递给析构函数

00A23708  call        dword ptr [ebp+14h] ;ebp+14h所代表的内存里面存放的是析构函数地址，这里调用析构函数

00A2370B  jmp         `eh vector destructor iterator'+51h (0A236F1h);跳转到地址0A236F1h执行

;后面是析构完对象之后的结束代码

可以看到，析构代理函数也是循环调用析构函数，以与构造对象相反的顺序析构对象。

比较对单个堆对象调用delete和对堆对象数组调用delete[]可以发现，两种情况最主要的差别是在用最后用delete释放堆空间时，delete[]会对目标指针(即对delete来说，目标指针为堆对象首地址，对delete[]来说，是堆中第一个堆对象首地址)进行减4调整.因此，如果是释放单个对象堆空间，错误的使用delete[],那么，执行中间检测时，会判断对象类型标记为3，进行目标指针调整，结果会释放错误的堆空间。同理，如果释放对象数组，而错误的使用delet，那么，执行中间检测时，会判断对象类型标记为1，不进行目标指针调整，堆空间的释放也会发生错误。

基本数据类型

下面是c++源码:

class X {

private:

    int _x;

public:

    X(int xx = ) : _x(xx) {}

    virtual ~X() {}

};

class Y  {

private:

    int _y;

public:

    Y(int yy = ) : _y(yy) {}

    virtual ~Y() {}

};

class Z : public X, public Y {

private:

    int _z;

public:

    Z(int zz = ) : _z(zz){}

    virtual ~Z() {}

};

int main()  {

    int* ip1 = new int[];

    delete [] ip1;

    int* ip2 = new int;

    delete ip2;

}

c++代码中ip1指向的是堆中基本类型int数组的首地址，ip1指向堆中单个基本类型int的首地址。

下面是mian函数里面的汇编码:

 :     int* ip1 = new int[];

00141A3E  push          ;将申请的堆空间大小压栈，作为参数传递给operator new

00141A40  call        operator new (141177h) ;调用operator new

00141A45  add         esp,  ;栈顶指针减4 释放为调用operator new传参时分配的栈空间

00141A48  mov         dword ptr [ebp-104h],eax  ;寄存器eax里面存有申请到的堆空间首地址，下面

                                                ;的代码都是一些传值操作

00141A4E  mov         eax,dword ptr [ebp-104h]

00141A54  mov         dword ptr [ip1],eax  ;eax的值传给了指针变量ip1

    :     delete [] ip1;

00141A57  mov         eax,dword ptr [ip1]  ;将ip1的值(指向堆空间首地址)给寄存器eax

00141A5A  mov         dword ptr [ebp-0F8h],eax  ;下面是一些传值操作

00141A60  mov         ecx,dword ptr [ebp-0F8h]

00141A66  push        ecx  ;ecx里面保存了堆空间首地址，这里将ecx压栈，为调用delete传参

00141A67  call        operator delete (141082h)  ;调用delete

00141A6C  add         esp,  ;栈顶指针减4，释放为调用delete传参时分配的栈空间

    :

    :     int* ip2 = new int;

00141A6F  push         ;将申请的堆空间大小压栈，作为餐宿传递给operator new

00141A71  call        operator new (141177h);调用operator new

00141A76  add         esp,  ;栈顶指针减4 释放为调用operator new传参时分配的栈空间

00141A79  mov         dword ptr [ebp-0ECh],eax  ;寄存器eax里面存有申请到的堆空间首地址，下面

                                                ;的代码都是一些传值操作

00141A7F  mov         eax,dword ptr [ebp-0ECh]

00141A85  mov         dword ptr [ip2],eax  ;eax的值给指针变量ip2

    :     delete ip2;

00141A88  mov         eax,dword ptr [ip2]  ;将ip2的值(指向堆空间首地址)给寄存器eax

00141A8B  mov         dword ptr [ebp-0E0h],eax   ;下面是一些传值操作

00141A91  mov         ecx,dword ptr [ebp-0E0h]

00141A97  push        ecx  ;ecx里面保存了堆空间首地址，这里将ecx压栈，为调用delete传参

00141A98  call        operator delete (141082h);调用delete

00141A9D  add         esp, ;栈顶指针减4，释放为调用delete传参时分配的栈空间

从汇编码可以看到，由于基本数据类型没有构造函数和析构函数，因此，这两种情况都只是简单的调用new分配空间，调用delete释放空间。并且还可以看到，和堆中对象数组不同，堆中基本类型数组没有在申请到的堆空间首地址处存放对象个数，ip1，ip2都直接指向的是各自申请到的堆空间首地址，正因为如此，对于基本类型，delete和delete[]效果一样。