关于指针和函数和字符数组的一些小结

指针

 

第一个指针问题：首先看三个程序如下图：

 

经过上面三个图大家已经看到第一个程序能够正常的运行，为什么后两个就不行呢？

正确的程序我就不再说为什么，首先说一下第二个程序为什么会报段错误呢？首先int *p定义了一个指向整型变量的指针，然后*p就是指向了一块具体的内存单元，然后将2赋值给*p应该是对的，但是却出现段错误，这是因为p为一个野指针，它没有指向一块可以预知的内存单元，这样做是很危险的，这个指针可能会指向系统的内存，这样可能使系统崩溃，，所以使用时一定要小心。

第三个程序也是一样的，这里不再累述

 

 

指针和字符数组的区别

 

请教：char *p="abcdef"和char s[]="abcdef"存储在哪里的问题？

这个程序编译通过，但是问什么程序运行会出错？ 

另一个： 
这个程序能够正常输出! 


请问这是为什么？ 
p,s和“abcdef”分别在那个区？

解答：

答案1：

#include <stdio.h> 
int main() 
{ 
char *p="abcdef"; //很多书上说：p在栈，“abcdef”在数据区 :没错！！！！
p[2]='W'; 
printf(“%s”,p); 
return 0; 
} 
这个程序编译通过，但是问什么程序运行会出错？ //p指向的是一块常量数据区，不能修改其值！！！！

另一个： 
#include <stdio.h> 
int main() 
{ 
char s[]="abcdef";//s在栈，“abcdef”在数据区 //正确！！！！！！！！！！
s[2]='W'; 

 printf(“%s”,s); 

return 0; 
} 
这个程序能够正常输出! //因为s是一个数组，分配的是一块栈上的内存，而上面只是一个指针，没申请内存！

char *p="abcdef"; //"abcdef" 静态存储区，是常量区，不可改, p[2]企图通过p这个指针改变常量区的内容，所以你这个程序编译通过，运行会出错？ 

char s[]="abcdef";//"abcdef" 静态存储区, 你赋值给s[]这个变量后，改变s[2]，所以不出错。 


p, s 在同一个区，如果是局部变量，就是在栈里面。 
"abcdef"; //静态存储区，是常量区，不可改 

答案2：

char s[]="abcdef";//s在栈，“abcdef”在栈区 
数组初始化, 等价于s[0]='a', s[1]='b'... 


可以简单认为数据区是不可写的,栈区是可写的 


是常量数据区不可写！！！！！！

 

 

————————————————————————————————————

char s[]="abcdef";//这是告诉编译器，要用一个字符数组，里面放上“abcdef”这个内容（编译器开一个空间放上字符数组的内容） 
char *p="abcdef"; //这个是告诉编译器，要用一个指针（编译器开一个空间放指针），让指针指向放着“abcdef”内容的地方，eoh，这时候没为“abcdef”开空间，那编译器就认为这个是常量字符串了，自己把它放常量区里，让指针指向常量区的这个串。既然是常量区的东西，那以后就不能改了，尽管p能指向并读取，但不能改写

 

 

 

大家可以再看一下这个代码：

#include <stdio.h>

#include <string.h> 

 

 

int main()

{

 

char *a="abcd";

char *b="llll";

strcat(a,b);

printf("%s",a);

} 

 

 

函数返回值—返回局部变量

 

 

 

（因截图太麻烦就不再截图）

看看下面的程序的输出： 

#include <stdio.h> 
char *show() 
{ 
     char *p="hello world!"; 
     return p; 
} 
int main() 
{ 
     char *str; 
     str=show(); 
     printf("%s\n", str); 
     return 0; 
} 

这个没有任何问题，因为"hello world!"是一个字符串常量，存放在静态数据区，把该字符串常量存放的静态数据区的首地址赋值给了指针，所以show函数退出时，该该字符串常量所在内存不会被回收，故能够通过指针顺利无误的访问。

但是，下面的就有问题： 

#include <stdio.h> 
char *show() 
{ 
     char p[]="hello world!"; 
     return p; 
} 
int main() 
{ 
     char *str; 
     str=show(); 
     printf("%s\n", str); 
     return 0; 
} 


"hello world!"是一个字符串常量，存放在静态数据区，没错，但是把一个字符串常量赋值给了一个局部变量(char []型数组)，该局部变量存放在栈中，这样就有两块内容一样的内存，这是与前着最本质的区别，当show函数退出时，栈要清空，局部变量的内存也被清空了，所以这时的函数返回的是一个已被释放的内存地址，所以打印出来的是乱码。

如果函数的返回值非要是一个局部变量的地址，那么该局部变量一定要申明为static类型。如下： 

#include <stdio.h> 
char *show() 
{ 
     static char p[]="hello world!"; 
     return p; 
} 
int main() 
{ 
     char *str; 
      str=show(); 
     printf("%s\n", str); 

     return 0; 
} 

这个问题可以通过下面的一个例子来更好的说明： 

#include <stdio.h> 
//返回的是局部变量的地址，该地址位于动态数据区，栈里 
char *s1() 
{ 
     char p[]="Hello world!"; 
     printf("in s1 p=%p\n", p); 
     printf("in s1: string's address: %p\n", &("Hello world!")); 
     return p; 
} 
//返回的是字符串常量的地址，该地址位于静态数据区 
char *s2() 
{ 
     char *q="Hello world!"; 
     printf("in s2 q=%p\n", q); 
     printf("in s2: string's address: %p\n", &("Hello world!")); 
     return q; 
} 
//返回的是静态局部变量的地址，该地址位于静态数据区 
char *s3() 
{ 
     static char r[]="Hello world!"; 
     printf("in s3 r=%p\n", r); 
     printf("in s3: string's address: %p\n", &("Hello world!")); 
     return r; 
} 
int main() 
{ 
     char *t1, *t2, *t3; 
     t1=s1(); 
     t2=s2(); 
     t3=s3(); 
     printf("in main:"); 
     printf("p=%p, q=%p, r=%p\n", t1, t2, t3); 
     printf("%s\n", t1); 
     printf("%s\n", t2); 
     printf("%s\n", t3); 
     return 0; 
}


运行输出结果： 
in s1 p=0xbff92efb 
in s1: string's address: 0x80486ac 
in s2 q=0x80486ac 
in s2: string's address: 0x80486ac 
in s3 r=0x804998c 
in s3: string 

这个结果正好应证了上面解释，同时，还可是得出一个结论：字 符串常量，之所以称之为常量，因为它可一看作是一个没有命名的字符串且为常量，存放在静态数据区。这里说的静态数据区，是相对于堆、栈等动态数据区而言 的。静态数据区存放的是全局变量和静态变量，从这一点上来说，字符串常量又可以称之为一个无名的静态变量，因为"Hello world!"这个字符串在函数 s1和s2 中都引用了，但在内存中却只有一份拷贝，这与静态变量性质相当神似。

char *p = "abcdefg";//静态存储区

char p[] = "abcdefg"; // p本身是数组名了，数组里放的字符串，是局部变量，内容是原来的静态区域内容的拷贝！

因此返回p实际上返回的局部变量地址而不是静态存储区地址，和上面不同！