问个菜鸟级的问题,关于new和delete

swen96

程序tst.C：
#include <stdio.h>;
#include <stdlib.h>;
#include <string.h>;
#include <ctype.h>;

char *pcToLowerChar(char *pcBuf)
{
    char *pcReturn;

    pcReturn = new char(strlen(pcBuf));
    memset(pcReturn, 0x00, strlen(pcBuf));

    printf("len=%d\n", strlen(pcBuf));
    for (int i = 0; i < strlen(pcBuf); i++)
    {
        *(pcReturn+i) = tolower(pcBuf);
    }
    delete pcReturn;
    return pcReturn;
}

main()
{
    char    acT[20];

    char    *p;

    strcpy(acT, "AAAAAAAAAAAA";

    printf("acT = %s\n", pcToLowerChar(acT));
}
在函数pcToLowerChar里new 了个指针变量pcReturn，在该函数返回前已经delete掉了，但程序执行的结果却返回正确。
这是否可以认为指针变量pcReturn在delete之后仍然存在呢？否则怎么会有正确的结果返回呢？
大侠们能帮我解释一下吗？

另外，在函数里定义了某局部指针变量,并new了空间，但在函数退出时，并没有delete掉该变量，像这种局部变量在该函数调用之后，系统是否会立即释放空间？还是一再占有着，直到整个程序退出后再释放？
再拿上面的代码来举例:

#include <stdio.h>;
#include <stdlib.h>;
#include <string.h>;
#include <ctype.h>;

char *pcToLowerChar(char *pcBuf)
{
    char *pcReturn;

    pcReturn = new char(strlen(pcBuf));
    memset(pcReturn, 0x00, strlen(pcBuf));

    printf("len=%d\n", strlen(pcBuf));
    for (int i = 0; i < strlen(pcBuf); i++)
    {
        *(pcReturn+i) = tolower(pcBuf);
    }
    //delete pcReturn;
    return pcReturn;
}

main()
{
    char    acT[20];

    char    *p;

    strcpy(acT, "AAAAAAAAAAAA";

    printf("acT = %s\n", pcToLowerChar(acT));
}

在这段代码里我没有手工delete  pcReturn，请问pcReturn是在main里调用pcToLowerChar(acT)之后被释放，还是整个程序(tst.C)退出之后再被释放的？

aero

1、delete掉了，只是说明这块内存不再受到保护，成为了一段自由的空间，可以被再次利用，但是，delete并不负责清空里面的内容（这样也是极其没有效率的）。用指针指着这块内存，依然可以看到它的内容。如此而已。不要太过死板的理解“存在”、“销毁”这样的概念。
2、C++不熟悉，如果是局部变量的话，应该函数退出的时候就释放了。

assiss

preturn这个变量本身在函数结束的时候就被销毁了,
但它指向的内存并没有自动被销毁.
如果没有显式地调用delete,那么它将一直存在到整个程序结束.由操作系统作主收回一切资源的时候.

swen96

[quote]原帖由 "aero"]1、delete掉了，只是说明这块内存不再受到保护，成为了一段自由的空间，可以被再次利用，但是，delete并不负责清空里面的内容（这样也是极其没有效率的）。用指针指着这块内存，依然可以看到它的内容。如此而已。不?.........[/quote 发表：


OK,首先感谢aero和assiss的指点，我想再问一下aero：
按照你的说法：
“如果是局部变量的话，应该函数退出的时候就释放了”
是否所有的局部指针变量都可以在new之后，不用手工delete，而让系统自动释放呢？因为“应该函数退出的时候就释放了”，再手工delete，岂不是多余？

aero

呵呵，感觉C++中new出来的东西不一定是在堆中，有可能是在栈中的局部变量，不太清楚，查查再说。

关于释放空间是否多余，习惯什么的问题，有过很多讨论。搜一下关于malloc和free的帖子，他们是C语言中管理内存的函数。

assiss

原帖由 "swen96" 发表：


OK,首先感谢aero和assiss的指点，我想再问一下aero：
按照你的说法：
“如果是局部变量的话，应该函数退出的时候就释放了”
是否所有的局部指针变量都可以在new之后，不用手工delete，而让系统自动释放呢？因?.........

我觉得aero说的并不对,c++中的new 与delete并非在栈中操作内存.它也是在堆中.如果你不手工DELETE的话,NEW出来的内存是一直占用着的.直到程序结束才会被系统收回.

converse

>;>;在函数pcToLowerChar里new 了个指针变量pcReturn，在该函数返>;>;回前已经delete掉了，但程序执行的结果却返回正确。
>;>;这是否可以认为指针变量pcReturn在delete之后仍然存在呢？否则怎么>;>;会有正确的结果返回呢？
>;>;大侠们能帮我解释一下吗？

还是基本概念的问题,delete只是宣布new出来的内存不再有效,也就是指针的指向不再有效,你返回的是指针的值,是new出来在堆里的地址,看我做过一点手脚的代码吧:

1. 
   
2. #include <stdio.h>;
   
3. #include <stdlib.h>;
   
4. #include <string.h>;
   
5. #include <ctype.h>;
   
6. 
   
7. char *pcToLowerChar(char *pcBuf)
   
8. {
   
9.         char *pcReturn;
   
10.        
    
11. 
    
12.         printf("before new pcReturn = %x\n", pcReturn);
    
13.         pcReturn = new char(strlen(pcBuf));
    
14. 
    
15.         printf("after new pcReturn = %x\n", pcReturn);       
    
16. 
    
17.         memset(pcReturn, 0x00, strlen(pcBuf));
    
18. 
    
19.         printf("len=%d\n", strlen(pcBuf));
    
20.         for (int i = 0; i < strlen(pcBuf); i++)
    
21.         {
    
22.                 *(pcReturn+i) = tolower(pcBuf[i]);
    
23.         }
    
24.         delete pcReturn;
    
25. 
    
26.         printf("after delete pcReturn = %x\n", pcReturn);       
    
27. 
    
28.         return pcReturn;
    
29. }
    
30. 
    
31. int main(void)
    
32. {
    
33.         char acT[20];
    
34. 
    
35.         char *p;
    
36. 
    
37.         printf("before init p = %x\n", p);
    
38. 
    
39.         strcpy(acT, "AAAAAAAAAAAA");
    
40.         p = pcToLowerChar(acT);
    
41. 
    
42.         printf("now p = %x\n", p);
    
43. 
    
44.         printf("acT = %s\n", p);
    
45. }
    

复制代码

输出如下:

1. 
   
2. before init p = 77e5ac21
   
3. before new pcReturn = 610ed060
   
4. after new pcReturn = a041078
   
5. len=12
   
6. after delete pcReturn = a041078
   
7. now p = a041078
   
8. acT =
   

复制代码

自己看看吧,因为new出来的内存不是在栈里而是在堆里,所以即使函数退出照样是可以访问的,但是可能是因为已经delete掉的原因所以printf是打印不出的.

或者你自己看看反汇编出来的代码自己理解看看,其实这个问题和:

1. 
   
2. int f()
   
3. {
   
4.      int n;
   
5.      n = 4;
   
6.      //.......
   
7.      return n;
   
8. }
   
9. 返回的是4
   

复制代码

是一样的道理,关键的是你要知道new出来的地址是在堆里,不会随着函数的结束的不能访问.

swen96

我明白了：在new 之后，必须delete，内存才能得以释放。
那么，像以上的代码，正确的写法应该是怎样？
怎样在一个函数内给一个指针变量分配内存，然后想通过该变量返回给调用函数一字符串，但该变量分配后又必须得释放，而释放后，虽然该地址仍然可以访问，但又不可靠，正确的写法应该是怎样,各位高手，给我一个答案?  这个问题经常遇见，但因为对指针的理解不深，不敢用，所以一直都用数组来处理

converse

原帖由 "swen96" 发表：
我明白了：在new 之后，必须delete，内存才能得以释放。
那么，像以上的代码，正确的写法应该是怎样？
怎样在一个函数内给一个指针变量分配内存，然后想通过该变量返回给调用函数一字符串，但该变量分配后又必须得..........

你这样的做法没有好的办法解决的,只能在函数中不delete掉,而在用完之后自己去delete.

系统给予你分配内存的权利,你就应该相应的担上返回内存的责任,也就是说要做到心中有数,写了一个new记得在合适的地方写一个delete.

如果你不想负起这个责任,在c++里有auto_ptr的东东负责自动的分配和返回内存,当然啦,它有自己的缺点,自己去掂量选择吧.

swen96

原帖由 "converse" 发表：


你这样的做法没有好的办法解决的,只能在函数中不delete掉,而在用完之后自己去delete.

系统给予你分配内存的权利,你就应该相应的担上返回内存的责任,也就是说要做到心中有数,写了一个new记得在合适的地方写一个..........

那你通常用什么样的方法来处理这种类似调用情况？简单举个例吧：）