谁帮忙看一下，这是什么原因？

[csdn0068]

有这样一个测试程序：
#include <string.h>
char * scpy(char a[], char b[])
{
char m[200];
int i = 0;
int j = 0;
while((m[i]=a[i]) != '\0')
{
i++;
}
while((m[i++]=b[j++]) != '\0');
printf("%s\n",m);
return m;
}
main()
{
char *a = "string";
char *b = "-test";
char *s = malloc(200);
s = scpy(a,b);
printf("%s\n",s);
}
在这种情况下输出：
string-test
string-test

变为如下情况后：
#include <string.h>
char * scpy(char a[], char b[])
{
char m[200];
int i = 0;
int j = 0;
while((m[i]=a[i]) != '\0')
{
i++;
}
while((m[i++]=b[j++]) != '\0');
//注释下面语句
//printf("%s\n",m);
return m;
}
main()
{
char *a = "string";
char *b = "-test";
char *s = malloc(200);
s = scpy(a,b);
printf("%s\n",s);
}
输出乱码：
h?

[blh]

It is typical case for using local varialbe incorrectly.
After your scpy function returns, local variable m has become invalid, so you will not get correct result. As for the first result, it is only good luck.

You can define m as static and try again.

[梁尚君]

#include <string.h>
char * scpy(char a[], char b[])
{
char m[200];
int i = 0;
int j = 0;
while((m[i]=a[i]) != '\0')
{
i++;
}
while((m[i++]=b[j++]) != '\0');
printf("%s\n",m);
return m;
}
main()
{
char *a = "string";
char *b = "-test";
char *s =(char*)malloc(200);/*修改*/
s = scpy(a,b);
printf("%s\n",s);
}
無論哪种情況都可以正常運行.
相當與:
char *s;
s=(char *)malloc(200);
為s指向200個字符空間的首地址

[wgsspank]

楼上所进行的修改，就能保证无论哪种情况都可以正常运行吗？请您说一下为什么！我觉的前几楼说的有道理！问题在于返回了一个local varialbe !这样本身就是不正确的！

[csdn0068]

char * scpy(char a[], char b[])确实返回了临时指针!!!
谁再给我解释一下这种情况（完全能正确执行）
char * scpy1(char *a,char *b)
{
char *m = malloc(200);
char * n;
n = m;
while(*a != '\0')
{
*m++ = *a++;
}
while(*b != '\0')
{
*m++ = *b++;
}
*m = '\0';
m = n;
return m;
}

main()
{
char *a = "string";
char *b = "-test";
char *s = malloc(200);
s = scpy1(a,b);
printf("%s\n",s);
}

char *m一样是临时指针。

[caidao1987]

学到东西了`顶一吓``

[sekelon]

*m确实是临时指针，但是在函数中*m使用了malloc分配了内存，并且在函数结束前并没有释放内存，所以指针m所指向的这块内存仍然是有效的，所以没有错。

[chenminyi]

临时指针应该可以返回，因为指针也是一种变量，而数组名不是，在K&R 的C程序设计语言上有返回局部指针这种用法

[庄鱼]

sekelon(罗伦罗亚索龙) 说得没错。
malloc在C里分配指针空间时，动用了远程分配表，那是一个全局指针链用于管理当前可用内存区间的。虽然m是一个临时变量，但由于没有通过free明确的释放，所以对应的值还是有效的。在C里，通常都是采用这种方法对链表、树、环等进行赋值操作的。

[jameswjue]

一直就有这样一个疑问今天终于明白了
谢谢!

[njSeeWhy]

如果指针是指向函数中在堆上分配的内存，那这个指针是可以返回到函数外的，因为堆上的内存在函数返回时不会自动释放。但是在栈上分配的内存就不行，所以char m[200]在函数返回后会变成无效（但内存中的内容不一定会清空），而 m=(char*)malloc（200)在函数返回后仍然有效。

[nicknide]

char *s = malloc(200);
s = scpy1(a,b);
这个地方难道就没有人看吗？

一开始S分配了内存，然后s改变了指向的地址单元，导致了内存丢失……大家为什么都忽视了这个问题了呢？
指针赙值，并没有指针指向的内容赙值啊
最后还有一定要释放内存，这些都是标准了

[ftkghost]

如果在意local variable的警告
把程序改成这样两种情况都可以
#include <string.h>
void scpy(char a[], char b[],char m[]) //增加一个形参char m[]，无返回值
{
int i = 0;
int j = 0;
while((m[i]=a[i]) != '\0')
{
i++;
}
while((m[i++]=b[j++]) != '\0');
//printf("%s\n",m);
return ;
}
int main()
{
char* a = "string";
char* b = "-test";
char m[200]; //m[200]数组放在main函数中就可以了
scpy(a,b,m); //把scpy当作一个过程来使用。
printf("%s\n",m);
return 0;
}

[BluntBlade]

你不走运罢了：）

[Paris_Luo]

这个函数返回了临时指针!!!

char * scpy(char a[], char b[])
{
char m[200];
int i = 0;
int j = 0;
while((m[i]=a[i]) != '\0')
{
i++;
}
while((m[i++]=b[j++]) != '\0');
printf("%s\n",m);
return m;<--------------------------------这
}

[njSeeWhy]

scpy中的m[200]是在栈上开辟的内存，函数退出时m会被释放，你把它返回给s，再打印s的话，就很有可能（但不是一定）出现乱码，因为这时s指向的的原来m占据的那块内存，而那块内存很有可能现在存放了其他的东西。至于为什么前面一个可以，那只能说——你走运罢了，呵呵。