| nico 回复于：2001-12-20 09:34:30
|
我也不太清楚，不过你试试下面这条语句：
return &tmpstr;
或者写成
return &tmpstr[0];
|
| taodale 回复于：2001-12-20 09:50:10
|
如果你学过编译原理的话，对这个问题就会很清楚了。
你在函数里所定义的一个变量是临时变量，如char tmpstr[255]; 它仅在函数的生存期内有效。临时变量在函数被调用的时候分配所需的存储空间，在函数返回以后，这块空间会被系统收回派其它用场，所以返回它没有任何意义。
正确的用法是：
char * getstr(){
char* tmpstr;
tmpstr=(char*) malloc(255);
strcpy(tmpstr,"------" ;
return tmpstr;
}
|
| nico 回复于：2001-12-20 10:25:13
|
楼上高水平，我很佩服，多谢了！
|
| nico 回复于：2001-12-20 18:48:30
|
哈哈！这个问题问得好！如果按taodale的说法，就必须在函数中回收空间了。因为在函数之外的地方是没有这个tmpstr的。
|
| Sinbad 回复于：2001-12-21 13:32:54
|
char *p;
p=getstr();
{ do something using p }
free(p);
|
| lylizm 回复于：2001-12-21 15:14:26
|
以下代码在sco下编译通过，结果正确。
#include <stdio.h>
int main(int argc,char **argv)
{
char *getstr();
char teststr[255];
strcpy(teststr,getstr());
printf("test [%s]\n",teststr);
exit(0);
}
char * getstr(){
char tmpstr[255];
strcpy(tmpstr,"Hello World!";
return tmpstr;
}
运行显示 test [Hello World!]
|
| nico 回复于：2001-12-23 13:40:05
|
include<stdio.h>
char * getstr()
{
char tmpstr[255];
strcpy(tmpstr,"------";
return tmpstr;
}
main()
{
printf("%s\n",getstr());
}
本程序在tc2.0下调试通过。
|
| fzheng 回复于：2001-12-23 15:46:31
|
nice的程序有一点问题，在编译的时候会有warning: pointer to local 'tmpstr' is
an illegal value.
其实，把程序改一下，就会发现错误。
#include <stdio.h>
char * getstr()
{
char tmpstr[255];
strcpy(tmpstr,"------";
return tmpstr;
}
void anther()
{
char test[255];
strcpy(test,"this is a test";
}
int
main()
{
char *p;
p=getstr();
anther();
printf("%s\n",p);
return 0;
}
结果是this is a test.堆栈中的数据被改变了。
|
| redwoods 回复于：2001-12-24 16:48:09
|
cod aas,你可不可以解释一下，为什么Sinbad的做法不可取。或者有什么好的办法可以解决这个问题。
我看着Sinbad的方法好像是对的。当然，我是个菜鸟，也不知道究竟对不对，而起现在出差在外，也没有办法试。
|
| nico 回复于：2001-12-25 10:41:56
|
free()仅能释放malloc()申请的空间有关，这一点我在自己家的机器上试过了。
我上面的程序是对的，编译用的是tc2.0， 在win98的dos窗口下通过的，并没有warning。
|
| flyfish 回复于：2001-12-25 12:39:18
|
我想Sinbad的用法是安全的，
原因就是taodale 的高论。
|
| redwoods 回复于：2001-12-25 13:40:47
|
nico,你能不能查一下malloc()分配的空间用free()释放的时候有什么要求没有，是不是超出了分配的函数的生存期就不能释放了？
我想如果free()能在函数外释放内存，那还是Sinbad的方法安全。原因见fzheng的程序。
但是还有一个问题，就是如果free()的释放不受限制，那重载的变量该怎么处理？
比如：
void test(void)
{ char * teststr;
teststr=(char *)malloc(200);
//do something,but not free teststr
return;
}
int main(int argc,char **argv)
{
char *teststr;
test();
teststr=(char*) malloc(255);
//do something...
free(teststr) ;
exit(0)
}
这会怎么样呢？
|
| alonemelive 回复于：2001-12-25 20:44:26
|
为什么不把字符串指针作为参数传进函数呢？？？
|
| lchsh 回复于：2001-12-26 15:36:48
|
楼上的朋友，你的变量根本就是两个变量，没有重载。
|
| nico 回复于：2001-12-29 11:08:26
|
[quote]
nico,你能不能查一下malloc()分配的空间用free()释放的时候有什么要求没有，是不是超出了分配的函数的生存期就不能释放了？
我想如果free()能在函数外释放内存，那还是Sinbad的方法安全。原因见fzheng的程序。
但是还有一个问题，就是如果free()的释放不受限制，那重载的变量该怎么处理？
比如：
void test(void)
{ char * teststr;
teststr=(char *)malloc(200);
//do something,but not free teststr
return;
}
int main(int argc,char **argv)
{
char *teststr;
test();
teststr=(char*) malloc(255);
//do something...
free(teststr) ;
exit(0)
}
这会怎么样呢？
[/quote]
free()仅释放main()中申请的空间。
但如果你试一下的话会发现在主函数中可以用函数test()中的teststr，也就是说free()掉main()中的teststr后，再次调用teststr后可以打出它的值。这是因为你设了两个相同的变量。不过，具体为什么会出现这种现象，用taodale的原理无法解释。我也不懂。
|
| fanyan1999 回复于：2001-12-29 11:39:09
|
我建议把程序改成这样：
void getstr(char *tmpstr){
strcpy(tmpstr,"------";
}
在函数中返回字符串的方法不安全，因为函数结束时为该函数分配的内存都会被释放掉。fzheng的话很有道理。佩服佩服！！！
|
| alai 回复于：2002-08-10 10:17:24
|
这确是一个简单的问题，没有一个标准答案，Sinbad的方法也是对的，但更通常的做法是将tmpstr定义为静态的，这样它的内存不会在getstr()退出时被释放，也不需要在外面用free()释放，不过第二次调用getstr()会覆盖前次的返回值。这种方法是在许多标准C函数中被使用。
char * getstr(){
static char tmpstr[255];
strcpy(tmpstr,"------";
return tmpstr;
}
|
| netstorm 回复于：2002-08-10 11:42:33
|
[quote][b]下面引用由[u]lylizm[/u]在 [i]2001/12/21 03:14pm[/i] 发表的内容：[/b]
以下代码在sco下编译通过，结果正确。
以下代码在sco下编译通过，结果正确。
#include <stdio.h>
int main(int argc,char **argv)
{
char *getstr();
char teststr[255];
strcpy(teststr,getstr());
printf("test [%s]\n",teststr);
exit(0);
}
char * getstr(){
char tmpstr[255];
strcpy(tmpstr,"Hello World!";
return tmpstr;
}
运行显示 test [Hello World!]
[/quote]
把 char tmpstr[255] 改成 char tmpstr[13]，运行你的程序会出什么问题？？
如果定义成 static char tmpstr[13]呢？？ ：）
|
| aegis 回复于：2002-08-10 12:09:21
|
nico 你的程序有问题，不能保证正确性
free () 能释放 malloc () 得到的内存。getstr () 函数不知是不是标准函数
我一般这样使用
c++:
char * p = new char [ 255 ];
/* do some worke with p */
delete p;
c:
char * p;
if ( null == (p = malloc ( 255 ) return ErrorNoMem;
/* do some work with p */
free ( * p ;
free () 可以在任何函数中使用，不必和 malloc 在同一作用域
但要注意 指针变量 的作用域问题;
|
| flw 回复于：2002-08-12 21:06:35
|
我认为诸位的方法都不好.其实还有一种方法,那就是将 char tmpstr[255]; 声明写做: static char tmpstr[255]; 即可.不过这样将加长"静态存储区"的长度, 所以更科学的方法应该是将函数声明改成 char *getstr( char *tmpstr ; 即 tmpstr 由形式参数传入, 至于其空间嘛, 就不是 getstr 的责任了, 完全可以由外部分配. 另外我点评一下 taodale
的做法: 这样做虽然可以,但是习惯不好,降低了函数模块的"内聚性",谁上的厕所谁就冲马桶嘛! 另外, lylizm 的做法依赖于编译器, 本来嘛, 局部变量是存在于堆栈中的,那么对它的指针引用在堆栈不发生变化的前提下应该不会有问题, 但是,这不是 C 的语法所要求的, 所以并不可行/可靠, 换句话说, 这样做有三种结果: 1. 编译不能通过(因为编译器要求太严), 2, 内容不正确(原因比较复杂), 3, 正确. 事实上, 我在 SCO Unix 5.05 下就发现有这样的情况: (参见 lylizm 的例子) 在函数外部输出的内容为: [Hello World] 注意, 丢失了最后一个字符, 我曾经把 "电话银行" 中客户输入的密码就丢失了一位, 最后才查出是这个原因.
总之, 1,当 tmpstr 较短时, 宜采用类似 static char tmpstr[6]; 的写法; 2, 当 tmpstr 较长时, 宜采用外部分配, 外部回收, getstr() 处理指针的方法.
|
| flw 回复于：2002-08-12 21:13:21
|
不好意思, 我发上面这个帖子的时候没有看见第二页上各位大侠的帖子.所以有些话不太得体.
|
| badeager 回复于：2002-08-31 13:19:46
|
#include <stdio.h>
char *getstr(char *tmpstr)
{
// char tmpstr[255];
strcpy(tmpstr,"------";
return tmpstr;
}
int
main()
{
char *p;
p = (char *)malloc(255);
p=getstr(p);
printf("%s\n",p);
return 0;
}
|
| sonice 回复于：2002-09-03 17:02:53
|
[quote][b]下面引用由[u]nico[/u]在 [i]2001/12/23 01:40pm[/i] 发表的内容：[/b]
include<stdio.h>
char * getstr()
{
char tmpstr;
...
[/quote]
char str[255] 申明的变量在 stack 中， 函数返回后就不确定了。编译成功只是巧合。malloc 出来的空间是在 heap 中，在进程的生存期都有效。所以 sinbad 和 badeager 的方法是最安全的。
|
| tianzhushan 回复于：2002-09-08 10:35:41
|
继续！
|
| tianzhushan 回复于：2002-09-08 10:42:23
|
这个函数的为什么没有输出为乱码？
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char *getmemory(void)
{
char p[]="hello world";
return p;
}
void test(void)
{
char str[100];
int i=0,len;
strcpy(str,getmemory());
printf("the str is:%s\n",str);
}
main()
{
test();
}
|
| sonice 回复于：2002-09-08 22:39:02
|
楼上的程序没有出错是巧合。解释如下：
char p[] = "hello world"; --> p 的空间在栈中，函数返回后栈空间就是自由空间了，可能被其他函数使用。你的函数没有出错是因为没有其他函数使用 p 所在的空间，但不能保证每次都这样。简单的程序不能说明问题，也证明不了什么。malloc 或者 new 出来的空间是在堆中，堆中声明的空间如果你不释放（free or delete），在整个进程的生存期都不会被改变。
btw: malloc 系列函数中有一个可以强迫在栈中声明空间，这种空间不用去释放。
|
| fred08 回复于：2002-10-11 10:20:05
|
我看了各位的解决方案，很多都是可行的，但我认为还是flw的最好最全面，因为这样比较安全，不会留下bug。
|
| dongdongwx 回复于：2002-10-11 11:36:32
|
能不用free的时候，最好不用她，不安全
给函数加一个字符串指针变量，好一点
|
| aegis 回复于：2002-10-13 02:55:18
|
看来笨蛋不少
free 当然可释放 malloc 获得的内存了，不论是在哪个函数中申请的
你编译过去，“调试通过”，只不过是凑巧罢了，程序太简单了
读书去吧
|
| redgoat 回复于：2002-10-14 14:53:28
|
[这个贴子最后由redgoat在 2002/10/14 02:54pm 编辑]
sonice,你没搞错吧？？！！ 应该是静态内存才对，而并不是在栈中
|
| flw 回复于：2002-10-24 18:26:35
|
[quote:d2e0b3965a="aegis"]看来笨蛋不少
free 当然可释放 malloc 获得的内存了，不论是在哪个函数中申请的
你编译过去，“调试通过”，只不过是凑巧罢了，程序太简单了
读书去吧[/quote:d2e0b3965a]
我同意这位仁兄的观点，我认为许多同学们还是应该把多读些语法方面的书，把语法重视起来，不要象我在别的地方听到的一样，竟然说潭老师的《C程序设计》罗罗嗦嗦，“没有实用价值”！
|
| 紫竹 回复于：2002-10-27 02:32:17
|
原因是某一函数中的非指针变量是存放于栈中的，在退出时全部释放，因此这些局部变量也就没其存在的基础。但返回的指针变量可以是局部指针变量。
|
| lljsun 回复于：2002-10-29 10:40:02
|
没有一点问题啊，我在sco unix上顺利编译运行，源代码一点没变。我觉得跟内存分配无关
char * getstr(){
char tmpstr[255];
strcpy(tmpstr,"------";
return tmpstr;
}
main(int argc,char argv[])
{
char t[200];
strcpy(t,getstr());
printf("getstr() :%s\n",t);
}
|
| stonepine 回复于：2002-10-29 10:57:42
|
taodale说得对，malloc()出来的内存区如果程序没有通过free()释放，会一直存在，即使程序退出，也会继续存在，只是此时变成不可访问的无用内存了。而临时变量以及数组则有它严格的作用域，由编译器分配和释放内存，redwoods在上面的帖子中没有注意变量的作用域问题，应该写成如下代码：
void test(void)
{
char * teststr;
teststr= malloc(200);
//do something,but not free teststr
return teststr;
}
int main(void)
{
char *teststr;
teststr = test();
if ( teststr free(teststr) ;
exit(0);
}
|
| xiangzg 回复于：2002-10-29 11:41:04
|
多了解一下c和c++编译系统，如果想做个好的程序员！
|
| zglcl008 回复于：2002-10-29 20:02:01
|
free()能在函数外释放内存
|
| cloudqin 回复于：2003-01-07 16:30:06
|
这个问题太弱智了！不知道是不是刚写程序的菜菜！
在函数内定义的char数组是属于堆栈内的，函数退出就被释放了，简单点可以这样：
void getstr(char* tmpstr){
strcpy(tmpstr,"------";
}
mani()
{
char tmpstr[255] = {0};
getstr(tmpstr);
/////do u anything////
printf("%s", tmpstr);
}
|
| cloudqin 回复于：2003-01-07 17:08:27
|
fff
|
| 晴天羽 回复于：2003-01-08 11:23:29
|
最好的用法还是用变量传递。
void getstr(char *p, int inlen)
{
p = (char *)malloc(inlen);
strcpy(p,"------";
return p;
}
|
| taige 回复于：2003-01-08 15:45:26
|
楼主的做法肯定是不对的，
即使在小的程序中，
表面上运行没有问题（楼上一些仁兄所列），
但是大程序中就不敢肯定没有问题，
实际上这应该算程序的一个大BUG。
当然在函数里面进行malloc()内存动态分配不会有问题，
但是要记得调用free()。
free的参数只是一个内存指针，
只要它指向的内存空间由malloc分配且未被free，
不用管在哪个函数里面由malloc分配的。
用static定义函数内的字符串变量也可以，
这样的话函数返回的时候，
该变量就不会释放，也就不会有问题。
当然，可以把一个字符串作为参数传入函数，
但是“晴天羽”的做法 
推荐在调用函数前定义好足够长的字符串变量。
个人觉得还是用static定义变量最简单 
|
| thigma 回复于：2003-02-25 19:15:16
|
数组名实际上是一个指向数组第一个元素的指针， 传送指针容易出错，并且不同编译器可能有不同的结果。
|
| HopeCao 回复于：2003-02-26 12:43:52
|
虽说实践是检验真理的标准，但是我们也不能被一些假象所迷惑！
有本书《高质量的C/C++编程》（好象是这样子的吧，是一个叫林锐的博士写的），他讲得很详细！！！！
|
| wwjxjtu 回复于：2003-02-26 21:13:29
|
char * getstr(){
char tmpstr[255];
strcpy(tmpstr,"------");
return &tmpstr;
}
[/u]
|
| unicorns 回复于：2003-02-27 11:29:07
|
也就是说
p1 = (char *)malloc(SIZE);
p2 = p1;
free(p2);
这时候p1和p2都是不可用的
因为p1和p2指向同一个空间，而这个空间已经被释放掉了
有没有warning看编译器而定吧
我在solaris下用gcc，使用free过的指针没有warning
但事实上再次调用malloc的时候p1和p2指向的空间就会被重新分配了
|
| yj 回复于：2003-03-11 21:06:51
|
还是好好看看C++的内存管理
|
| biansj 回复于：2003-03-11 23:28:14
|
看到很热闹，我也来凑凑热闹。
看了看大家的讨论，差不多有四个观点：
1.直接返回局部变量
2.返回静态局部变量
3.在接口内分配内存
4.传指针及指针长度
第一种肯定是错的,大家也说了,主要原因是局部变量的内存空间已经被系统收回,不再可用.
第二种FLW所持的观点,并且有很多拥护者,可是我不同意,请看下面这段代码
[code:1:18f5b8196d]
#include "stdio.h"
char *fun(int flag)
{
static char str[100];
if(flag==1)
strcpy(str,"hello,world!");
else
strcpy(str,"world,hello!");
printf("str's id:%d,value:%s!\n",str,str);
return str;
}
int main()
{
char *ptr;
ptr=fun(1);
printf("ptr's id:%d,value:%s!\n",ptr,ptr);
fun(2);
printf("ptr's id:%d,value:%s!\n",ptr,ptr);
return 0;
}
[/code:1:18f5b8196d]
就是说这片神圣的局部静态内存可能会在一个不小心或不注意的情况下会被玷污掉,尤其是fun这个函数是一个比较底层的函数时,如果在一个程序中被很多不同的模块调用,而不同的模块的编写人不同时,这将绝对是一个噩梦! 
很对不起,说话有点重,大家不要在意! 
第三种情况如果是你自己开发,自己用还可以,如果是很多人在开发,每个人负责不同的模块,最后不同的模块编译出一个程序,可以说,这个程序80%的可能存在[color=red:18f5b8196d]memory leak!![/color:18f5b8196d]
我还是比较赞成第四种,但是应该多加一些错误判断,如:
[code:1:18f5b8196d]
#include "stdio.h"
#include "string.h"
#include "assert.h"
int fun(char *l_value,int len)
{
char str[100];
assert(l_value);
strcpy(str,"hello,world!");
if(strlen(str)>len)
return 1;
else
strcpy(l_value,str);
return 0;
}
int main()
{
char *ptr=NULL;
int len=5;
ptr=(char *)malloc(sizeof(char)*len);
if(fun(ptr,len))
printf("Error!\n");
else
printf("ptr's id:%d,value:%s!\n",ptr,ptr);
free(ptr);
return 0;
}
[/code:1:18f5b8196d]
大家可以参考一下,互相交流吗! 
欢迎大家讨论!
|
| flw 回复于：2003-03-12 16:38:14
|
楼上的兄台说的有道理！
不过需要声明一下：
[quote:cae896e034="flw 于 2002-08-12 日 21:06 分"]所以更科学的方法应该是将函数声明改成 char *getstr( char *tmpstr ; 即 tmpstr 由形式参数传入, 至于其空间嘛, 就不是 getstr 的责任了, 完全可以由外部分配[/quote:cae896e034]
我其实也是赞同“第四种做法”的。
|
| ygzq 回复于：2003-04-08 06:26:02
|
There is limitation of method 4:
it could NOT cope if u don't know the buffer size before calling a function, i.e., the buffer size has to be dynamically calculated inside the function.
As far as approach 3 is concerned, there is indeed some memory leak risk. hoever, a good programmer should always check the man page to see if you need to free. this is the one what i preferred.
|
| zhhui2000 回复于：2003-04-13 17:24:55
|
我觉得这样是比较安全的：
#include <stdio.h>
char * getstr(char *buf,int len)
{
strcpy(buf,"------");
if (strlen(buf) > len) buf[0]='\0';
return buf;
}
int
main()
{
char *p;
int len=255;
p=(char*)malloc(sizeof(char)*len);
getstr(p,len);
printf("%s\n",p);
return 0;
}
|
| aero 回复于：2003-04-13 19:51:36
|
我觉得楼上的仁兄做法有些欠妥。
一、buf是作为形式参数送进函数getstr的，在getstr中也没有改变buf的值（虽
然它指向的值改变了），用return返回有点多余，程序罗嗦，降低了可读性。
二、这样做也是不安全的。如果在getstr中"---------"的串如果长于len，那么
有可能造成main函数中开辟的255个空间后面的空间被占用、被修改，而这段空间
是没有保护的，如果是重要的程序代码就会造成严重的错误。虽然你在getstr里
加了出错判断，但是占用未被保护空间是在strcpy那句，判断错误的时候错误有
可能已经发生了，而且是不可挽回的。
仅仅是讨论问题，如果说话有不得体的地方，还请仁兄包涵。
另外biansj和flw讲得都很好。让小弟学到很多东西。
|
| zhhui2000 回复于：2003-04-14 11:07:41
|
楼上兄弟批评的有道理，我没有仔细分析。
|
| linbird 回复于：2003-04-14 23:13:52
|
[quote:a7ee002185="taodale"]仅在函数的生存期内有效。临时变量在函数被调用的时候分配所需的存储空间，在函数返回以后，这块空间会被系统收回派其它用场，所以返回它没有任何意义。
正确的用法是：
char * getstr(){
char* tmpstr;
..........[/quote:a7ee002185]
|
| lycxlove 回复于：2003-04-17 16:36:36
|
[quote:7f9450bc1d="nico"] strcpy(tmpstr,"------");
return tmpstr;
}
main()
{
printf("%s\n",getstr());
}
本程序在tc2.0下调试通过。
[/quote:7f9450bc1d]
nico的是对的，可是为什么，我是菜鸟，谁能解释一下
|
| lycxlove 回复于：2003-04-17 16:36:36
|
[quote:bf6a3f5728="nico"] strcpy(tmpstr,"------");
return tmpstr;
}
main()
{
printf("%s\n",getstr());
}
本程序在tc2.0下调试通过。
[/quote:bf6a3f5728]
nico的是对的，可是为什么，我是菜鸟，谁能解释一下
|
| flw 回复于：2003-04-17 16:50:25
|
[quote:b543d8e9fc="aero"]我觉得楼上的仁兄做法有些欠妥。
一、buf是作为形式参数送进函数getstr的，在getstr中也没有改变buf的值（虽
然它指向的值改变了），用return返回有点多余，程序罗嗦，降低了可读性。
[/quote:b543d8e9fc]
这一点就是 aero 的不对了。
其实这种写法即使是在系统函数里也很常见，主要是为了充分利用函数的“返回值”这个资源，反正每一个函数都有一个返回值嘛！
为了说明不是画蛇添足，请考虑一下以下这个写法：
str = malloc();
fprintf( stderr, "读取到的数据是：[%s]", getstr( str ;
...
如果不返回值就不行。
|
| blublusky 回复于：2003-04-17 18:22:10
|
这样就行了
#include <stdio.h>
char * getstr()
{
char tmpstr[255];
strcpy(tmpstr,"------");
return tmpstr;
}
void anther()
{
char test[255];
strcpy(test,"this is a test");
}
int
main()
{
char p[100];
memset(p,0,sizeof(p));
strcpy(p, getstr());
anther();
printf("%s\n",p);
return 0;
}
|
| li2002 回复于：2003-07-23 07:08:45
|
biansj说：
[quote:3d02557780]#include "stdio.h"
char *fun(int flag)
{
static char str[100];
if(flag==1)
strcpy(str,"hello,world!");
else
strcpy(str,"world,hello!");
printf("str's id:%d,value:%s!\n",str,str);
return str;
}
int main()
{
char *ptr;
ptr=fun(1);
printf("ptr's id:%d,value:%s!\n",ptr,ptr);
fun(2);
printf("ptr's id:%d,value:%s!\n",ptr,ptr);
return 0;
}
就是说这片神圣的局部静态内存可能会在一个不小心或不注意的情况下会被玷污掉,尤其是fun这个函数是一个比较底层的函数时,如果在一个程序中被很多不同的模块调用,而不同的模块的编写人不同时,这将绝对是一个噩梦!
很对不起,说话有点重,大家不要在意! [/quote:3d02557780]
我怎么不知道这有什么问题啊？那位详细说说。
|
| HolyArcher 回复于：2003-08-19 23:42:54
|
nico的代码确实是有问题的,之所以自己认为结果看起来是对的,是因为局部变量所使用的那块内存暂时还没有被使用. 如果在函数中使用malloc申请了内存,使用的是局部变量的指针,那么如果不在该函数中用free的话,这块内存就吊死了,不能被其他变量使用.
|
| yuonunix 回复于：2003-09-10 10:27:28
|
[quote:9f3de57c47="fzheng"]rcpy(test,"this is a test");
}
int
main()
{
char *p;
p=getstr();
anther();
printf("%s\n",p);
return 0;
}
结果是this is a test.堆栈中的数据被改变了。
[/quote:9f3de57c47]
你的分析很透彻，但我按照你的思路做了个测试例子，测试结果却和你的预期不符合，不知能否解释一二；
测试结果为：
结果的输出为----，而不是this is a test
#include <string>
using namespace std;
string getstr()
{
string aa = "kkk";
aa = "----";
return aa;//这里返回的应该是个临时变量，按照大家的理论，出了这个函数，aa的内存就被释放了
}
void anther()
{
char test[255];
strcpy(test,"this is a test");
}
void anther2()
{
char test[255];
strcpy(test,"this is a test");
}
int
main()
{
string p;
p=getstr();
anther2();
printf("%s\n",p.c_str ());
return 0;
}
|
| chaoge 回复于：2003-09-11 13:05:30
|
[quote:4591cbcb63="suyer"]
strcpy(tmpstr,"------");
return tmpstr;
}
为什么编译出现：
function returns address of local variable！
究竟什么意思？为什么返回本地地址就不可以？
请教各位了！
系统是REDHAT 7。1[/quote:4591cbcb63]
呵呵，你把局部变量tmpstr改成static就行了。
|
| chaoge 回复于：2003-09-11 13:16:28
|
呵呵，顶楼的朋友可以把局部变量tmpstr设置成static就行了。
|
| xingj_h 回复于：2003-09-13 15:34:41
|
不错
|
