void mm(char *p)
{
char b[]="test1
";//这一行[Warning] assignment makes integer from pointer without a cast char b[]="test1
";/
{
char b[]="test1
void mm(char *p)
{
char b[]="test1\0";//这一行[Warning] assignment makes integer from pointer without a cast
*p =b ;
}
int main(void){
char a[]="first\0";
char *str ;
str=a;
mm(str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
执行结果还是first,而非test,高手帮我解答一下,为什么会这样,怎样才打出test?
{
char b[]="test1\0";//这一行[Warning] assignment makes integer from pointer without a cast
*p =b ;
}
int main(void){
char a[]="first\0";
char *str ;
str=a;
mm(str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
执行结果还是first,而非test,高手帮我解答一下,为什么会这样,怎样才打出test?
6 个解决方案
#1
错误原因 返回局部变量
#2
char b[]是局部变量,出了mm方法消失.p指向的内存块内容未知?是不是这样的?
#3
void mm(char *p)
{
*p ="test1\0" ;//但这样,还是没有打出test1这个字符串来.
}
int main(void){
char a[]="first\0";
char *str ;
//str=a;
mm(str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
{
*p ="test1\0" ;//但这样,还是没有打出test1这个字符串来.
}
int main(void){
char a[]="first\0";
char *str ;
//str=a;
mm(str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
#4
是的
void mm(char** p)
{
*p="test";
}
int main(void){
char *str=0 ;
mm(&str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
void mm(char** p)
{
*p="test";
}
int main(void){
char *str=0 ;
mm(&str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
#5
在c中,自动变量在堆栈中分配内存,当包含自动变量的函数或代码块退出时,它们所占用的内存便被回收,他们的内容肯定会被下一个所调的函数覆盖.
解决这个问题的几个方案:
1.返回一个指向字符串长量的指针
char *fun()
{
return "For simple strings";
}
如果需要计算字符串的内容就无能为力了!
2.使用全局声明的数组
char *fun()
{
...
my_global[i]=...;
... return my_global;
}
这适用于自创建字符的情况,缺点在于任何人都可能在任何时候修改这个全局数组.下次调用也会影响覆盖此时数组的内容.
3.使用静态数组
char *fun()
{
static char buffer[256];
... return buffer;
}
可以防止任何人修改此数组,只有拥有指向该数组的指针的函数(通过参数传递)才能修改.但是,函数下一次调用将覆盖这个数组的内容.所以调用者必须在此前使用或备份数组内容.和全局数组一样,大型缓冲区如果闲置不用是非常浪费内存的.
4.显示分配一些内存,保存返回的值
char *fun()
{
char *s=malloc(20);
... return s;
}
这个方法具有静态数组的优点,而且在每次调用时都创建一个新的缓冲区,所以该函数以后的调用不会覆盖以前的返回值.缺点在于必须承担内存管理的责任.如果内存尚在使用就free或者"内存泄露"就会有bug
5.要求调用着分配内存来保存函数的返回值,为了提高安全性,应指定缓冲区的大小(像fgets()一样)
void fun(char *result,int size)
{
...
strmcpy(result,"That be in the data",size);
}
int main(void)
{
buffer=malloc(size);
fun(buffer,size);
...
free(buffer);
...
return 0;
}
可以在统一代码块中进行malloc和free操作
解决这个问题的几个方案:
1.返回一个指向字符串长量的指针
char *fun()
{
return "For simple strings";
}
如果需要计算字符串的内容就无能为力了!
2.使用全局声明的数组
char *fun()
{
...
my_global[i]=...;
... return my_global;
}
这适用于自创建字符的情况,缺点在于任何人都可能在任何时候修改这个全局数组.下次调用也会影响覆盖此时数组的内容.
3.使用静态数组
char *fun()
{
static char buffer[256];
... return buffer;
}
可以防止任何人修改此数组,只有拥有指向该数组的指针的函数(通过参数传递)才能修改.但是,函数下一次调用将覆盖这个数组的内容.所以调用者必须在此前使用或备份数组内容.和全局数组一样,大型缓冲区如果闲置不用是非常浪费内存的.
4.显示分配一些内存,保存返回的值
char *fun()
{
char *s=malloc(20);
... return s;
}
这个方法具有静态数组的优点,而且在每次调用时都创建一个新的缓冲区,所以该函数以后的调用不会覆盖以前的返回值.缺点在于必须承担内存管理的责任.如果内存尚在使用就free或者"内存泄露"就会有bug
5.要求调用着分配内存来保存函数的返回值,为了提高安全性,应指定缓冲区的大小(像fgets()一样)
void fun(char *result,int size)
{
...
strmcpy(result,"That be in the data",size);
}
int main(void)
{
buffer=malloc(size);
fun(buffer,size);
...
free(buffer);
...
return 0;
}
可以在统一代码块中进行malloc和free操作
#6
void mm(char **p)
{
char b[]="test1\0";//这一行[Warning] assignment makes integer from pointer without a cast
*p =b ;
}
int main(void){
char a[]="first\0";
char *str ;
str=a;
mm(&str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
{
char b[]="test1\0";//这一行[Warning] assignment makes integer from pointer without a cast
*p =b ;
}
int main(void){
char a[]="first\0";
char *str ;
str=a;
mm(&str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
";//这一行[Warning] assignment makes integer from pointer without a cast char b[]="test1
void mm(char *p)
{
char b[]="test1\0";//这一行[Warning] assignment makes integer from pointer without a cast
*p =b ;
}
int main(void){
char a[]="first\0";
char *str ;
str=a;
mm(str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
执行结果还是first,而非test,高手帮我解答一下,为什么会这样,怎样才打出test?
{
char b[]="test1\0";//这一行[Warning] assignment makes integer from pointer without a cast
*p =b ;
}
int main(void){
char a[]="first\0";
char *str ;
str=a;
mm(str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
执行结果还是first,而非test,高手帮我解答一下,为什么会这样,怎样才打出test?
6 个解决方案
#1
错误原因 返回局部变量
#2
char b[]是局部变量,出了mm方法消失.p指向的内存块内容未知?是不是这样的?
#3
void mm(char *p)
{
*p ="test1\0" ;//但这样,还是没有打出test1这个字符串来.
}
int main(void){
char a[]="first\0";
char *str ;
//str=a;
mm(str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
{
*p ="test1\0" ;//但这样,还是没有打出test1这个字符串来.
}
int main(void){
char a[]="first\0";
char *str ;
//str=a;
mm(str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
#4
是的
void mm(char** p)
{
*p="test";
}
int main(void){
char *str=0 ;
mm(&str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
void mm(char** p)
{
*p="test";
}
int main(void){
char *str=0 ;
mm(&str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
#5
在c中,自动变量在堆栈中分配内存,当包含自动变量的函数或代码块退出时,它们所占用的内存便被回收,他们的内容肯定会被下一个所调的函数覆盖.
解决这个问题的几个方案:
1.返回一个指向字符串长量的指针
char *fun()
{
return "For simple strings";
}
如果需要计算字符串的内容就无能为力了!
2.使用全局声明的数组
char *fun()
{
...
my_global[i]=...;
... return my_global;
}
这适用于自创建字符的情况,缺点在于任何人都可能在任何时候修改这个全局数组.下次调用也会影响覆盖此时数组的内容.
3.使用静态数组
char *fun()
{
static char buffer[256];
... return buffer;
}
可以防止任何人修改此数组,只有拥有指向该数组的指针的函数(通过参数传递)才能修改.但是,函数下一次调用将覆盖这个数组的内容.所以调用者必须在此前使用或备份数组内容.和全局数组一样,大型缓冲区如果闲置不用是非常浪费内存的.
4.显示分配一些内存,保存返回的值
char *fun()
{
char *s=malloc(20);
... return s;
}
这个方法具有静态数组的优点,而且在每次调用时都创建一个新的缓冲区,所以该函数以后的调用不会覆盖以前的返回值.缺点在于必须承担内存管理的责任.如果内存尚在使用就free或者"内存泄露"就会有bug
5.要求调用着分配内存来保存函数的返回值,为了提高安全性,应指定缓冲区的大小(像fgets()一样)
void fun(char *result,int size)
{
...
strmcpy(result,"That be in the data",size);
}
int main(void)
{
buffer=malloc(size);
fun(buffer,size);
...
free(buffer);
...
return 0;
}
可以在统一代码块中进行malloc和free操作
解决这个问题的几个方案:
1.返回一个指向字符串长量的指针
char *fun()
{
return "For simple strings";
}
如果需要计算字符串的内容就无能为力了!
2.使用全局声明的数组
char *fun()
{
...
my_global[i]=...;
... return my_global;
}
这适用于自创建字符的情况,缺点在于任何人都可能在任何时候修改这个全局数组.下次调用也会影响覆盖此时数组的内容.
3.使用静态数组
char *fun()
{
static char buffer[256];
... return buffer;
}
可以防止任何人修改此数组,只有拥有指向该数组的指针的函数(通过参数传递)才能修改.但是,函数下一次调用将覆盖这个数组的内容.所以调用者必须在此前使用或备份数组内容.和全局数组一样,大型缓冲区如果闲置不用是非常浪费内存的.
4.显示分配一些内存,保存返回的值
char *fun()
{
char *s=malloc(20);
... return s;
}
这个方法具有静态数组的优点,而且在每次调用时都创建一个新的缓冲区,所以该函数以后的调用不会覆盖以前的返回值.缺点在于必须承担内存管理的责任.如果内存尚在使用就free或者"内存泄露"就会有bug
5.要求调用着分配内存来保存函数的返回值,为了提高安全性,应指定缓冲区的大小(像fgets()一样)
void fun(char *result,int size)
{
...
strmcpy(result,"That be in the data",size);
}
int main(void)
{
buffer=malloc(size);
fun(buffer,size);
...
free(buffer);
...
return 0;
}
可以在统一代码块中进行malloc和free操作
#6
void mm(char **p)
{
char b[]="test1\0";//这一行[Warning] assignment makes integer from pointer without a cast
*p =b ;
}
int main(void){
char a[]="first\0";
char *str ;
str=a;
mm(&str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
{
char b[]="test1\0";//这一行[Warning] assignment makes integer from pointer without a cast
*p =b ;
}
int main(void){
char a[]="first\0";
char *str ;
str=a;
mm(&str);
printf("%s\n",str);
system("PAUSE");
return 0;
}
";/