| 网站首页 | 业界新闻 | 小组 | 威客 | 人才 | 下载频道 | 博客 | 代码贴 | 在线编程 | 编程论坛
欢迎加入我们,一同切磋技术
用户名:   
 
密 码:  
共有 1870 人关注过本帖
标题:释放?不释放?实践是检验真理的唯一标准
取消只看楼主 加入收藏
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
结帖率:100%
收藏
 问题点数:0 回复次数:10 
释放?不释放?实践是检验真理的唯一标准
感谢版主加高亮!

发这贴的原因是因为有这一帖 https://bbs.bccn.net/thread-375036-1-1.html

程序代码:

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

int main(void)
{
    char a[64] = {0};
    strcpy(a, "我用这个数组放一个字符串");
    printf("a是:%s\n", a);
   
    {
        //这是个大括号里面
        char b[64] = {0};
        strcpy(b, a);
        printf("b是:%s\n", b);
    }
    //理论上到这里b就释放了 而且写代码用这个b也确实会出错
   
    return 0;
}



GCC 4.6.2 编译参数  gcc a.c -Wall -std=c99

程序代码:

0x004013b7 <main+0>:   push   ebp
0x004013b8 <main+1>:   mov    ebp,esp
0x004013ba <main+3>:   push   edi
0x004013bb <main+4>:   push   esi
0x004013bc <main+5>:   push   ebx
0x004013bd <main+6>:   and    esp,0xfffffff0
0x004013c0 <main+9>:   sub    esp,0x90
0x004013c6 <main+15>:  call   0x40196c <__main>
0x004013cb <main+20>:  lea    ebx,[esp+0x50]
0x004013cf <main+24>:  mov    al,0x0
0x004013d1 <main+26>:  mov    edx,0x40
0x004013d6 <main+31>:  mov    edi,ebx
0x004013d8 <main+33>:  mov    ecx,edx
0x004013da <main+35>:  rep stos BYTE PTR es:[edi],al
0x004013dc <main+37>:  lea    eax,[esp+0x50]
0x004013e0 <main+41>:  mov    edx,eax
0x004013e2 <main+43>:  mov    ebx,0x408064
0x004013e7 <main+48>:  mov    eax,0x19
0x004013ec <main+53>:  mov    edi,edx
0x004013ee <main+55>:  mov    esi,ebx
0x004013f0 <main+57>:  mov    ecx,eax
0x004013f2 <main+59>:  rep movs BYTE PTR es:[edi],BYTE PTR ds:[esi]
0x004013f4 <main+61>:  lea    eax,[esp+0x50]
0x004013f8 <main+65>:  mov    DWORD PTR [esp+0x4],eax
0x004013fc <main+69>:  mov    DWORD PTR [esp],0x40807d
0x00401403 <main+76>:  call   0x40138c <printf>
0x00401408 <main+81>:  lea    ebx,[esp+0x10]
0x0040140c <main+85>:  mov    al,0x0
0x0040140e <main+87>:  mov    edx,0x40
0x00401413 <main+92>:  mov    edi,ebx
0x00401415 <main+94>:  mov    ecx,edx
0x00401417 <main+96>:  rep stos BYTE PTR es:[edi],al
0x00401419 <main+98>:  lea    eax,[esp+0x50]
0x0040141d <main+102>: mov    DWORD PTR [esp+0x4],eax
0x00401421 <main+106>: lea    eax,[esp+0x10]
0x00401425 <main+110>: mov    DWORD PTR [esp],eax
0x00401428 <main+113>: call   0x406170 <strcpy>
0x0040142d <main+118>: lea    eax,[esp+0x10]
0x00401431 <main+122>: mov    DWORD PTR [esp+0x4],eax
0x00401435 <main+126>: mov    DWORD PTR [esp],0x408086
0x0040143c <main+133>: call   0x40138c <printf>
0x00401441 <main+138>: mov    eax,0x0
0x00401446 <main+143>: lea    esp,[ebp-0xc]
0x00401449 <main+146>: pop    ebx
0x0040144a <main+147>: pop    esi
0x0040144b <main+148>: pop    edi
0x0040144c <main+149>: pop    ebp
0x0040144d <main+150>: ret    



反汇编如上

在整个main()中 堆栈只是在开始和结束的时候动过(sub    esp,0x90 lea    esp,[ebp-0xc]) 也就是说 所谓的释放是子虚乌有 直到函数返回 堆栈才会释放

以上均为个人意见 仅供参考 不当处望指正 谢谢

==============================偶素华丽的分割线==============================

马上有大牛批评了 立马再试

程序代码:

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

int main(void)
{
    char a[64] = {0};
    strcpy(a, "我用这个数组放一个字符串");
    printf("a是:%s\n", a);
   
    {
        //这是个大括号里面
        char b[64] = {0};
        strcpy(b, a);
        printf("b是:%s\n", b);
    }
    //理论上到这里b就释放了
   
    char c[64] = "这里再有一个字符串应该是不增加堆栈大小才对";
    printf("c是:%s\n", c);

    return 0;
}



编译参数 gcc -Wall -std=c99 a.c

反汇编如下

程序代码:

0x004013b7 <main+0>:   push   ebp
0x004013b8 <main+1>:   mov    ebp,esp
0x004013ba <main+3>:   push   edi
0x004013bb <main+4>:   push   esi
0x004013bc <main+5>:   push   ebx
0x004013bd <main+6>:   and    esp,0xfffffff0
0x004013c0 <main+9>:   sub    esp,0xd0
0x004013c6 <main+15>:  call   0x4019b4 <__main>
0x004013cb <main+20>:  lea    ebx,[esp+0x90]
0x004013d2 <main+27>:  mov    al,0x0
0x004013d4 <main+29>:  mov    edx,0x40
0x004013d9 <main+34>:  mov    edi,ebx
0x004013db <main+36>:  mov    ecx,edx
0x004013dd <main+38>:  rep stos BYTE PTR es:[edi],al
0x004013df <main+40>:  lea    eax,[esp+0x90]
0x004013e6 <main+47>:  mov    edx,eax
0x004013e8 <main+49>:  mov    ebx,0x408064
0x004013ed <main+54>:  mov    eax,0x19
0x004013f2 <main+59>:  mov    edi,edx
0x004013f4 <main+61>:  mov    esi,ebx
0x004013f6 <main+63>:  mov    ecx,eax
0x004013f8 <main+65>:  rep movs BYTE PTR es:[edi],BYTE PTR ds:[esi]
0x004013fa <main+67>:  lea    eax,[esp+0x90]
0x00401401 <main+74>:  mov    DWORD PTR [esp+0x4],eax
0x00401405 <main+78>:  mov    DWORD PTR [esp],0x40807d
0x0040140c <main+85>:  call   0x40138c <printf>
0x00401411 <main+90>:  lea    ebx,[esp+0x10]
0x00401415 <main+94>:  mov    al,0x0
0x00401417 <main+96>:  mov    edx,0x40
0x0040141c <main+101>: mov    edi,ebx
0x0040141e <main+103>: mov    ecx,edx
0x00401420 <main+105>: rep stos BYTE PTR es:[edi],al
0x00401422 <main+107>: lea    eax,[esp+0x90]
0x00401429 <main+114>: mov    DWORD PTR [esp+0x4],eax
0x0040142d <main+118>: lea    eax,[esp+0x10]
0x00401431 <main+122>: mov    DWORD PTR [esp],eax
0x00401434 <main+125>: call   0x4061b8 <strcpy>
0x00401439 <main+130>: lea    eax,[esp+0x10]
0x0040143d <main+134>: mov    DWORD PTR [esp+0x4],eax
0x00401441 <main+138>: mov    DWORD PTR [esp],0x408086
0x00401448 <main+145>: call   0x40138c <printf>
0x0040144d <main+150>: lea    edx,[esp+0x50]
0x00401451 <main+154>: mov    ebx,0x408098
0x00401456 <main+159>: mov    eax,0x2b
0x0040145b <main+164>: mov    edi,edx
0x0040145d <main+166>: mov    esi,ebx
0x0040145f <main+168>: mov    ecx,eax
0x00401461 <main+170>: rep movs BYTE PTR es:[edi],BYTE PTR ds:[esi]
0x00401463 <main+172>: lea    ebx,[esp+0x7b]
0x00401467 <main+176>: mov    al,0x0
0x00401469 <main+178>: mov    edx,0x15
0x0040146e <main+183>: mov    edi,ebx
0x00401470 <main+185>: mov    ecx,edx
0x00401472 <main+187>: rep stos BYTE PTR es:[edi],al
0x00401474 <main+189>: lea    eax,[esp+0x50]
0x00401478 <main+193>: mov    DWORD PTR [esp+0x4],eax
0x0040147c <main+197>: mov    DWORD PTR [esp],0x40808f
0x00401483 <main+204>: call   0x40138c <printf>
0x00401488 <main+209>: mov    eax,0x0
0x0040148d <main+214>: lea    esp,[ebp-0xc]
0x00401490 <main+217>: pop    ebx
0x00401491 <main+218>: pop    esi
0x00401492 <main+219>: pop    edi
0x00401493 <main+220>: pop    ebp
0x00401494 <main+221>: ret    




sub    esp,0xd0

是耶非耶


我在下面又定义了一个数组 如果上面大括号里面的数组被【释放】或【重新分配】 则我这个新程序和老程序的堆栈大小应该是一样的 可是呢 并不一样 可见 所谓的大括号可以【释放】内存或【重新分配】内存是子虚乌有的 唯一的功能就是明确这些变量的作用域 而这个功能是比较鸡肋的 因为只能在一个函数内用 比神马 命名空间 差的远罢

再次重申 个人意见 仅供参考

传下exe罢
c99_braces.zip (50.78 KB)


==============================偶素华丽的分割线==============================

程序代码:
#include <stdio.h>
#include <string.h>

int main(void)
{
    char a[64] = {0};
    strcpy(a, "我用这个数组放一个字符串");
    printf("a(%p)是:%s\n", a, a);
   
    {
        //这是个大括号里面
        char b[64] = {0};
        strcpy(b, a);
        printf("b(%p)是:%s\n", b, b);
    }
    //理论上到这里b就释放了
   
    char c[64] = "这里再有一个字符串应该是不增加堆栈大小才对";
    printf("c(%p)是:%s\n", c, c);

    return 0;
}




bash-3.1$ ./c99.exe
a(0022ff00)是:我用这个数组放一个字符串
b(0022fe80)是:我用这个数组放一个字符串
c(0022fec0)是:这里再有一个字符串应该是不增加堆栈大小才对



[ 本帖最后由 zklhp 于 2012-8-11 00:02 编辑 ]
2012-08-10 17:03
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
以下是引用TonyDeng在2012-8-10 17:11:18的发言:

你在后面再分配一个变量看看用了哪个空间。“宣告不要”跟“释放资源”是两回事,正如释放指针也没有清空所指地址的数据。

多谢大牛批评指正
2012-08-10 17:21
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
从这个测试结果看 所谓的大括号能释放内存或者说是减少内存使用或其他神马 目前是无法实现的

或许有参数能让编译器实现这个特性 谁知道啊
2012-08-10 17:33
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
以下是引用信箱有效在2012-8-10 18:46:16的发言:

能把用C99编译好的EXE发上来不。。。

已发
2012-08-10 18:54
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
以下是引用TonyDeng在2012-8-10 19:36:40的发言:

你第二个程序的证明逻辑本身就不对劲。执行文件的汇编码和机器码,都是静态代码,程序还没有执行,何来的释放、应该堆栈大小一样?代码明摆着就分配了那些空间,一个都不能少。想办法看到执行时的情况才行。

您说的极是
2012-08-10 19:54
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
以下是引用TonyDeng在2012-8-10 19:19:31的发言:

这是你第二个代码的汇编文件,你看看它是怎样的:

 
; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.40219.01  
 
    TITLE    e:\test2.cpp
    .686P
    .XMM
    include listing.inc
    .model    flat
 
INCLUDELIB MSVCRTD
INCLUDELIB OLDNAMES
 
PUBLIC    ??_C@_08GAIPLOLA@c?J?G?$KD?$LK?$CFs?6?$AA@    ; `string'
PUBLIC    ??_C@_0CL@LCHNGBJP@?U?b?$MA?o?T?Y?S?P?R?$LL?$LI?v?W?V?$LH?$PL?$LE?$KO?S?$KG?$LI?C?J?G?$LC?$LL?T?v?$LM?S?$LG?Q@ ; `string'
PUBLIC    ??_C@_08HHPEKKPD@b?J?G?$KD?$LK?$CFs?6?$AA@    ; `string'
PUBLIC    ??_C@_08EOHJJGDG@a?J?G?$KD?$LK?$CFs?6?$AA@    ; `string'
PUBLIC    ??_C@_0BJ@PJBNBAIL@?N?R?S?C?U?b?$LI?v?J?$PN?W?i?$LH?E?R?$LL?$LI?v?W?V?$LH?$PL?$LE?$KO?$AA@ ; `string'
PUBLIC    __$ArrayPad$
PUBLIC    _main
EXTRN    __imp__printf:PROC
EXTRN    _strcpy:PROC
EXTRN    ___security_cookie:DWORD
EXTRN    @__security_check_cookie@4:PROC
EXTRN    @_RTC_CheckStackVars@8:PROC
EXTRN    __RTC_CheckEsp:PROC
EXTRN    _memset:PROC
EXTRN    __RTC_Shutdown:PROC
EXTRN    __RTC_InitBase:PROC
;    COMDAT ??_C@_08GAIPLOLA@c?J?G?$KD?$LK?$CFs?6?$AA@
; File e:\my_documents\projects\c_test\test2\test2.cpp
CONST    SEGMENT
??_C@_08GAIPLOLA@c?J?G?$KD?$LK?$CFs?6?$AA@ DB 'c', 0caH, 0c7H, 0a3H, 0baH
    DB    '%s', 0aH, 00H                ; `string'
CONST    ENDS
;    COMDAT ??_C@_0CL@LCHNGBJP@?U?b?$MA?o?T?Y?S?P?R?$LL?$LI?v?W?V?$LH?$PL?$LE?$KO?S?$KG?$LI?C?J?G?$LC?$LL?T?v?$LM?S?$LG?Q@
CONST    SEGMENT
??_C@_0CL@LCHNGBJP@?U?b?$MA?o?T?Y?S?P?R?$LL?$LI?v?W?V?$LH?$PL?$LE?$KO?S?$KG?$LI?C?J?G?$LC?$LL?T?v?$LM?S?$LG?Q@ DB 0d5H
    DB    0e2H, 0c0H, 0efH, 0d4H, 0d9H, 0d3H, 0d0H, 0d2H, 0bbH, 0b8H, 0f6H
    DB    0d7H, 0d6H, 0b7H, 0fbH, 0b4H, 0aeH, 0d3H, 0a6H, 0b8H, 0c3H, 0caH
    DB    0c7H, 0b2H, 0bbH, 0d4H, 0f6H, 0bcH, 0d3H, 0b6H, 0d1H, 0d5H, 0bbH
    DB    0b4H, 0f3H, 0d0H, 0a1H, 0b2H, 0c5H, 0b6H, 0d4H, 00H ; `string'
CONST    ENDS
;    COMDAT ??_C@_08HHPEKKPD@b?J?G?$KD?$LK?$CFs?6?$AA@
CONST    SEGMENT
??_C@_08HHPEKKPD@b?J?G?$KD?$LK?$CFs?6?$AA@ DB 'b', 0caH, 0c7H, 0a3H, 0baH
    DB    '%s', 0aH, 00H                ; `string'
CONST    ENDS
;    COMDAT ??_C@_08EOHJJGDG@a?J?G?$KD?$LK?$CFs?6?$AA@
CONST    SEGMENT
??_C@_08EOHJJGDG@a?J?G?$KD?$LK?$CFs?6?$AA@ DB 'a', 0caH, 0c7H, 0a3H, 0baH
    DB    '%s', 0aH, 00H                ; `string'
CONST    ENDS
;    COMDAT ??_C@_0BJ@PJBNBAIL@?N?R?S?C?U?b?$LI?v?J?$PN?W?i?$LH?E?R?$LL?$LI?v?W?V?$LH?$PL?$LE?$KO?$AA@
CONST    SEGMENT
??_C@_0BJ@PJBNBAIL@?N?R?S?C?U?b?$LI?v?J?$PN?W?i?$LH?E?R?$LL?$LI?v?W?V?$LH?$PL?$LE?$KO?$AA@ DB 0ceH
    DB    0d2H, 0d3H, 0c3H, 0d5H, 0e2H, 0b8H, 0f6H, 0caH, 0fdH, 0d7H, 0e9H
    DB    0b7H, 0c5H, 0d2H, 0bbH, 0b8H, 0f6H, 0d7H, 0d6H, 0b7H, 0fbH, 0b4H
    DB    0aeH, 00H                    ; `string'
CONST    ENDS
;    COMDAT rtc$TMZ
rtc$TMZ    SEGMENT
__RTC_Shutdown.rtc$TMZ DD FLAT:__RTC_Shutdown
rtc$TMZ    ENDS
;    COMDAT rtc$IMZ
rtc$IMZ    SEGMENT
__RTC_InitBase.rtc$IMZ DD FLAT:__RTC_InitBase
; Function compile flags: /Odtp /RTCsu /ZI
rtc$IMZ    ENDS
;    COMDAT _main
_TEXT    SEGMENT
_c$ = -216                        ; size = 64
_b$4520 = -144                        ; size = 64
_a$ = -72                        ; size = 64
__$ArrayPad$ = -4                    ; size = 4
_main    PROC                        ; COMDAT
 
; 5    : {
 
  00000    55         push     ebp
  00001    8b ec         mov     ebp, esp
  00003    81 ec 9c 01 00
    00         sub     esp, 412        ; 0000019cH
  00009    53         push     ebx
  0000a    56         push     esi
  0000b    57         push     edi
  0000c    8d bd 64 fe ff
    ff         lea     edi, DWORD PTR [ebp-412]
  00012    b9 67 00 00 00     mov     ecx, 103        ; 00000067H
  00017    b8 cc cc cc cc     mov     eax, -858993460        ; ccccccccH
  0001c    f3 ab         rep stosd
  0001e    a1 00 00 00 00     mov     eax, DWORD PTR ___security_cookie
  00023    33 c5         xor     eax, ebp
  00025    89 45 fc     mov     DWORD PTR __$ArrayPad$[ebp], eax
 
; 6    :     char a[64] = {0};
 
  00028    c6 45 b8 00     mov     BYTE PTR _a$[ebp], 0
  0002c    6a 3f         push     63            ; 0000003fH
  0002e    6a 00         push     0
  00030    8d 45 b9     lea     eax, DWORD PTR _a$[ebp+1]
  00033    50         push     eax
  00034    e8 00 00 00 00     call     _memset
  00039    83 c4 0c     add     esp, 12            ; 0000000cH
 
; 7    :     strcpy(a, "我用这个数组放一个字符串");
 
  0003c    68 00 00 00 00     push     OFFSET ??_C@_0BJ@PJBNBAIL@?N?R?S?C?U?b?$LI?v?J?$PN?W?i?$LH?E?R?$LL?$LI?v?W?V?$LH?$PL?$LE?$KO?$AA@
  00041    8d 45 b8     lea     eax, DWORD PTR _a$[ebp]
  00044    50         push     eax
  00045    e8 00 00 00 00     call     _strcpy
  0004a    83 c4 08     add     esp, 8
 
; 8    :     printf("a是:%s\n", a);
 
  0004d    8b f4         mov     esi, esp
  0004f    8d 45 b8     lea     eax, DWORD PTR _a$[ebp]
  00052    50         push     eax
  00053    68 00 00 00 00     push     OFFSET ??_C@_08EOHJJGDG@a?J?G?$KD?$LK?$CFs?6?$AA@
  00058    ff 15 00 00 00
    00         call     DWORD PTR __imp__printf
  0005e    83 c4 08     add     esp, 8
  00061    3b f4         cmp     esi, esp
  00063    e8 00 00 00 00     call     __RTC_CheckEsp
 
; 9    :   
; 10   :     {
; 11   :         //这是个大括号里面
; 12   :         char b[64] = {0};
 
  00068    c6 85 70 ff ff
    ff 00         mov     BYTE PTR _b$4520[ebp], 0
  0006f    6a 3f         push     63            ; 0000003fH
  00071    6a 00         push     0
  00073    8d 85 71 ff ff
    ff         lea     eax, DWORD PTR _b$4520[ebp+1]
  00079    50         push     eax
  0007a    e8 00 00 00 00     call     _memset
  0007f    83 c4 0c     add     esp, 12            ; 0000000cH
 
; 13   :         strcpy(b, a);
 
  00082    8d 45 b8     lea     eax, DWORD PTR _a$[ebp]
  00085    50         push     eax
  00086    8d 8d 70 ff ff
    ff         lea     ecx, DWORD PTR _b$4520[ebp]
  0008c    51         push     ecx
  0008d    e8 00 00 00 00     call     _strcpy
  00092    83 c4 08     add     esp, 8
 
; 14   :         printf("b是:%s\n", b);
 
  00095    8b f4         mov     esi, esp
  00097    8d 85 70 ff ff
    ff         lea     eax, DWORD PTR _b$4520[ebp]
  0009d    50         push     eax
  0009e    68 00 00 00 00     push     OFFSET ??_C@_08HHPEKKPD@b?J?G?$KD?$LK?$CFs?6?$AA@
  000a3    ff 15 00 00 00
    00         call     DWORD PTR __imp__printf
  000a9    83 c4 08     add     esp, 8
  000ac    3b f4         cmp     esi, esp
  000ae    e8 00 00 00 00     call     __RTC_CheckEsp
 
; 15   :     }
; 16   :     //理论上到这里b就释放了
; 17   :   
; 18   :     char c[64] = "这里再有一个字符串应该是不增加堆栈大小才对";
 
  000b3    b9 0a 00 00 00     mov     ecx, 10            ; 0000000aH
  000b8    be 00 00 00 00     mov     esi, OFFSET ??_C@_0CL@LCHNGBJP@?U?b?$MA?o?T?Y?S?P?R?$LL?$LI?v?W?V?$LH?$PL?$LE?$KO?S?$KG?$LI?C?J?G?$LC?$LL?T?v?$LM?S?$LG?Q@
  000bd    8d bd 28 ff ff
    ff         lea     edi, DWORD PTR _c$[ebp]
  000c3    f3 a5         rep movsd
  000c5    66 a5         movsw
  000c7    a4         movsb
  000c8    33 c0         xor     eax, eax
  000ca    89 85 53 ff ff
    ff         mov     DWORD PTR _c$[ebp+43], eax
  000d0    89 85 57 ff ff
    ff         mov     DWORD PTR _c$[ebp+47], eax
  000d6    89 85 5b ff ff
    ff         mov     DWORD PTR _c$[ebp+51], eax
  000dc    89 85 5f ff ff
    ff         mov     DWORD PTR _c$[ebp+55], eax
  000e2    89 85 63 ff ff
    ff         mov     DWORD PTR _c$[ebp+59], eax
  000e8    88 85 67 ff ff
    ff         mov     BYTE PTR _c$[ebp+63], al
 
; 19   :     printf("c是:%s\n", c);
 
  000ee    8b f4         mov     esi, esp
  000f0    8d 85 28 ff ff
    ff         lea     eax, DWORD PTR _c$[ebp]
  000f6    50         push     eax
  000f7    68 00 00 00 00     push     OFFSET ??_C@_08GAIPLOLA@c?J?G?$KD?$LK?$CFs?6?$AA@
  000fc    ff 15 00 00 00
    00   ...
这里面连机器码都打了 不好看啊。。
2012-08-10 19:55
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
_c$ = -216                        ; size = 64
_b$4520 = -144                        ; size = 64
_a$ = -72                        ; size = 64

DWORD PTR _a$[ebp]
DWORD PTR _b$4520[ebp]
DWORD PTR _c$[ebp]

而整个过程中ebp都没变 结论和上面的一样

2012-08-10 20:13
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
以下是引用信箱有效在2012-8-10 20:26:32的发言:

我最近股悬梁锥刺头的发奋学习汇编。。。 感觉太勃大精深了。
程序虽然没执行,但是有足够的也是唯一需要的信息在代码里面,就是栈桢。
分析栈桢可以知道参数和局部变量的分配情况。
楼上的楼上的楼上的代码是直接分析的CPP文件啊。。。还是反汇编EXE比较好。

.text:004013B7 ; Attributes: bp-based frame
.text:004013B7
.text:004013B7 sub_4013B7      proc near               ; CODE XREF: sub_401000+B4p
.text:004013B7
.text:004013B7 var_DC          = dword ptr -0DCh
.text:004013B7 var_D8          = dword ptr -0D8h
.text:004013B7 var_CC          = byte ptr -0CCh
.text:004013B7 var_8C          = byte ptr -8Ch
.text:004013B7 var_61          = byte ptr -61h
.text:004013B7 var_4C          = byte ptr -4Ch

你说的这个么 这个好像是逆向的罢
2012-08-10 21:11
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
以下是引用pangding在2012-8-10 22:52:37的发言:

我就喜欢讨论这些概念性的问题。有关分配和释放的时机问题,C99 标准只字未提:
翻译:
之后标准用了一些篇幅,诠释各个对象的生命期是什么。

注意标准的用语,生命期是保证对象储存空间存在的时期。也就是说,对象可以在生命期开始的那一刹那分配,在消失的那一刹那回收。也可以不是,但储存的只能比这个长,不能比这个短。
事实上现在一般的实现,在执行权转入函数时统一分配局部变量,转回时统一回收都是符合标准的做法。当然也可以有其它做法,不过一般都要权衡相应行为代价。

这些和我一直以来的理解是一致的 标准万岁
2012-08-10 22:57
zklhp
Rank: 20Rank: 20Rank: 20Rank: 20Rank: 20
来 自:china
等 级:贵宾
威 望:254
帖 子:11485
专家分:33241
注 册:2007-7-10
收藏
得分:0 
以下是引用demonleer在2012-8-10 23:10:59的发言:

我擦 这是唱哪出
 
别逼我再把汇编找出来看

感谢版主高亮
2012-08-11 00:03
快速回复:释放?不释放?实践是检验真理的唯一标准
数据加载中...
 
   



关于我们 | 广告合作 | 编程中国 | 清除Cookies | TOP | 手机版

编程中国 版权所有,并保留所有权利。
Powered by Discuz, Processed in 0.031290 second(s), 9 queries.
Copyright©2004-2024, BCCN.NET, All Rights Reserved