文章目录
- 一、回顾
- 二、字符指针
- 1.基本用法
- 2.误区
- (1)字符指针存放字符串首元素地址
- (2)输出问题
- 3.内存布局
- 三、字符指针与字符串数组
- 1.字符指针
- 2.字符串数组
- 四、面试题
- 1.One
- 2.Two
- 3.探究
- 4.补充
- 五、地址问题
- 六、字符数组与字符串数组
- 1.sizeof与strlen
- 含义
- 示例一
- 示例二
- 说明
- 代码三
- 代码四
- 总结
- 2.字符数组与字符串数组
- 示例一
- 示例二
- 总结
一、回顾
指针的主题,我们在(2条消息) C语言基础–初识指针_雨翼轻尘的博客-CSDN博客已经接触过了。我们知道了指针的概念:
1、 指针就是个变量,用来存放地址,地址唯一标识一块内存空间。
2、 指针的大小是固定的4/8个字节(32平台/64平台)。
3、 指针有类型,指针的类型决定了指针的±整数的步长,指针解引用操作的时候的权限。
4、 指针的运算。
这一章节,我们继续探讨。
首先再来说明一下指针大小的问题。
看如下代码,输出结果是多少呢?
#include void test(int arr[]) { int sz = sizeof(arr) / sizeof(arr[0]); printf("%d\n", sz); } int main() {int arr[10] = { 0 }; test(arr); }
分析一下这个函数:
void test(int arr[]) {//arr是指针变量 int sz = sizeof(arr) / sizeof(arr[0]);//sizeof(arr)求指针大小-->4个字节(32平台) //sizeof(arr[0])是求一个元素的大小,整型-->4个字节 //于是:sizeof(arr)/sizeof(arr[0])=4/4=1 printf("%d\n", sz); }
经过分析,输出结果是1。
在编辑器里面运行也是1:
有的小伙伴说,我输出的是2啊?
别急,我配置一下这个地方。
如图,打开配置管理器:
将平台改为x64平台:
这时候,再次运行,发现结果就是2:
简单分析一下:
void test(int arr[]) {//arr是指针变量 int sz = sizeof(arr) / sizeof(arr[0]);//sizeof(arr)求指针大小-->8个字节(64平台) //sizeof(arr[0])是求一个元素的大小,整型-->4个字节 //于是:sizeof(arr)/sizeof(arr[0])=8/4=2 printf("%d\n", sz); }
二、字符指针
在指针类型中我们知道有一种指针类型为字符指针char*
。
1.基本用法
之前我们初识指针的时候,说过用法。
如下定义:
char ch = 'w';//字符变量chchar* pc=&ch;//将字符变量ch的地址取出来,存在pc中。pc就被称为字符指针,类型就是char*
字符指针是一个指针变量,里面存放一个字符的地址。
将字符指针解引用,可以找到字符。
*pc = 'w';
2.误区
(1)字符指针存放字符串首元素地址
看如下代码:
int main(){char* pstr="hello";printf("%s\n",pstr);return 0;}
看第一行代码。
❓ 这里,是把一个字符串**“hello”**存放到pstr指针变量里面了吗?
注意
代码char* pstr="hello";
,
特别容易让我们以为是把字符串hello放到了字符指针pstr里面。
但本质是把字符串hello的首字母地址
存放到了pstr中。
其实一般这里有两种理解:
第一种理解是错误的!
第二种理解是正确的。a的地址赋值给了p。(常量字符串有什么需要注意的地方,后边讲解。)
可以输出看一下,p指针解引用之后的结果:
输出结果是a, p里面存放的是a的地址
!
再想一个问题:
既然p里面存放的是a的地址,那么如果打印的话,是否能打印出来abcdef呢?
不妨试一下:
printf("%s\n",p);
总结
将字符串赋值给一个字符指针变量p,不是把字符串的内容赋值给p,而是把字符串首字符的地址赋给了p。
后边讲内存布局的时候,给大家补充一下为何输出结果是这样的。
(2)输出问题
举个例子:
int main() { char arr[] = "abcdef";//字符串存入arr数组里面char* pc=arr;//pc字符指针存放数组名,即首元素地址。 printf("%s\n", arr); printf("%s\n", pc); return 0;}
上面代码打印结果是多少呢?
因为将arr存给pc了,所以打印结果都是abcdef。
看一下输出结果:
3.内存布局
还是用上面的代码;
char* p="abcdef";
这行代码的意思,来探讨一下:
①将字符串”abcdef”存放在内存中某个位置。
“abcdef”是常量字符串。
既然”abcdef”字符串放在内存中,就会有它的起始地址。
②假设它的起始地址是:0x0012ff44,
那么字符指针变量p里面存放的就是该字符串的首字符地址,即0x0012ff44。
p能够通过该地址,找到该字符串。
如下图:
③这时候将p打印出来
printf("%s\n",p);
遇到\0
就停止打印,所以就可以打印出来整个字符串。
补充
有的小伙伴可能不太理解为何打印整个字符串,这里解释一下:
打印一个字符,用
%c
,p里面存的是a的地址,*p就是a。打印整个字符,遇到**“\0”**停止,用
%s
,p里面存的就是a的地址。直接把p放在后面,就从p存的地址处开始打印一个字符串,就能打印出“abcdef”。
给大家看一下:
①这里要用*p
:
②这里要用p
:
最后再强调一下,
字符串要赋给指针变量p,不是把字符串的内容赋给p,而是把这个字符串的首字母的地址
赋给了p。
三、字符指针与字符串数组
可能上边大家会有点晕,这里梳理一下字符指针与字符串数组。
1.字符指针
还是这行代码:
char* p="abcdef";
之前我们说过,这里的"abcdef"
是常量字符串,常量字符串有什么需要注意的地方呢?
- 可以通过字符指针输出字符串
int main(){char* p="abcdef";printf("%s",p);return 0;}
输出结果:
也可以输出部分字符串:
int main(){char* p="abcdef";printf("%s",p+2);return 0;}
输出结果:
- 字符指针里面存放的是常量字符串首字符的地址,可以通过地址找到字符串每个字符。
比如我们可以输出看一下:
int main(){int i=0;char* p="abcdef";for(i=0;i<7;i++){printf("%c",*(p+i));}return 0;}
输出结果:
- 不可以通过指针,改变常量字符串的任意字符。
既然p里面存放的是a的地址,那么*p
就是a。
现在想把a改成w,这样写可以吗?
*p='w';
输出看一下:
我们会发现,编译是没有问题的,但是运行是有问题的。
编译器崩溃:
调试看一下,出现异常:
如果在Linux系统下会出现Segmentation fault
(段错误)的错误。
写入访问权限冲突,访问非法内存。
号外
当时在栈溢出的时候介绍了一个网站: www.stackoverflow.com
今天再介绍一个网站:SegmentFault 思否
再回到刚才报错的代码:
**“abcdef”**是一个常量字符串,常量字符串里面的东西不能被修改!
这里正确的写法,是需要给char* p
之前加一个const
。
const修饰的是*p
,即p所指向的内容不能被修改,P指向的字符串不能被修改。
const char* p="abcdef";
如果要修改,就会报错:
不修改,可以正常输出:
- 可以改变指针指向的字符串
这儿的“abcdef”是字符串常量,指针指向了放在只读内存区中的常量,只读区域不允许改变。
而w
是字符常量,要是一个字符串,就可以。
字符串数组,赋初值的时候,系统就分配好了内存,这儿的内存在只读区域中。
如果想要修改,只能这样:(让p指针指向其他字符串)
int main(){const char* p="abcdef";printf("%s\n",p);p="abc";//让p指针指向其他字符串printf("%s\n",p);return 0;}
看一下:
修改后的指针p并没有修改“abcdef”的值,而是指向了一个新的字符串。
2.字符串数组
- 先输出看一下arr里面存的字符串。
int main(){char arr[]="abcdef";printf("arr=%s\n",arr);return 0;}
输出看一下:
可以输出整个字符串,也可以输出部分,比如:
int main(){char arr[]="abcdef";printf("%s\n",arr+2);return 0;}
输出结果:
- 常量字符串存放进数组,内存中是一个字符一个字符的存进去的。
比如“abcdef”存进去就是”abcdef\0″。
可以分别输出看一下:
int main() {int i = 0;char arr[] = "abcdef";for (i = 0; i < 7; i++) {printf("arr[%d]=%c\n", i,arr[i]);}return 0;}
输出结果:
注意,arr[6]的值是0,如果没有值输出,就会输出问号,这个地方没有显示而已:
- 字符串既然是一个一个存放进数组,就可以修改字符串里面的字符。
比如,现在想修改第二个字符为h
。
int main() {char arr[] = "abcdef";arr[1] = 'h';printf("%c\n", arr[1]);printf("%s", arr);return 0;}
输出:
也不能修改整个字符串:
int main(){char arr[]="abcdef";arr="ghty";printf("arr=%s\n",arr);return 0;}
输出报错:
四、面试题
1.One
有这样一道面试题:
int main() { char arr1[] = "abcdef"; char arr2[] = "abcdef"; char* p1 = "abcdef"; char* p2 = "abcdef"; if (arr1==arr2) {printf("hehe\n"); } else {printf("haha\n"); } return 0;}
这个面试题输出结果是多少呢?
看一下:
❓ 为什么结果是“haha”?
我们创建了两个数组,arr1
和arr2
,它们在内存中一定是有两块空间的,两个数组的数组名当然是两个不同的首元素地址了。
即arr1不等于arr2的地址。所以打印“haha”。
2.Two
我们再换一个代码看看:(注意if语句里面的判断)
int main() { char arr1[] = "abcdef"; char arr2[] = "abcdef"; char* p1 = "abcdef";char* p2 = "abcdef"; if (p1 == p2) {printf("hehe\n");}else {printf("haha\n"); }return 0;}
打印输出看一下:
❓ 现在打印的结果为啥是“hehe”?
常量字符串
不能被修改。
两个字符串既然一模一样,又是常量字符串,各自又不能修改,没有必要再在内存中存两份。只需要拿去用,不能改它。
为了在内存中节省空间,这两个“abcdef”只存了一份。(这一点非常重要)
不管是p1还是p2,都指向同一块空间的起始位置。
而第一次没有修改代码之前,是创建两个不同的数组,地址是不一样的。
3.探究
①不妨输出看一下p1与p2指向的地址,看一下是否相同:
int main() { char arr1[] = "abcdef"; char arr2[] = "abcdef"; char* p1 = "abcdef";char* p2 = "abcdef"; printf("%p\n",p1);printf("%p\n",p2);return 0;}
看一下结果,是一样的:(注意是它们指向的地址相同,这两个指针本身的地址是不一样的)
②再看一下p1与p2本身的地址:
int main() { char arr1[] = "abcdef"; char arr2[] = "abcdef"; char* p1 = "abcdef";char* p2 = "abcdef"; printf("%p\n",&p1);printf("%p\n",&p2);return 0;}
输出看一下,结果是不一样的:(两个指针的本身地址不同)
这里也能发现,if语句判断的是,两个指针指向的空间地址是否相同。而不是判断两个指针本身的地址。
4.补充
改变p1并不能改变p2。
更何况p1和p2指向的常量字符串是不可修改的。
p1和p2是两个独立的空间,指向同一个地址:
标准写法:
标准写法,需要给字符指针前面加上const
:
int main() { char arr1[] = "abcdef"; char arr2[] = "abcdef"; const char* p1 = "abcdef";const char* p2 = "abcdef";return 0;}
p1与p2指向的地址就是字符串的地址,如下:
五、地址问题
关于上面的面试题,可能还有小伙伴不明白。
这里将它们的地址都打印出来,一起做个比较。
测试一段代码:
int main() {char arr1[] = "abcdef";char arr2[] = "abcdef";char* p1 = "abcdef";char* p2 = "abcdef";printf("abcdef=%p\n","abcdef");printf("&arr1[0]=%p\n", &arr1[0]);printf("&arr2[0]=%p\n", &arr2[0]);printf("arr1=%p\n", arr1);printf("arr2=%p\n", arr2);printf(" &p1=%p\n", &p1);printf("&p2=%p\n", &p2);printf("p1=%p\n", p1);printf("p2=%p\n", p2);printf("&(*p1)=%p\n", &(*p1));printf("&(*p2)=%p\n", &(*p2));return 0;}
输出结果:
可以看到,地址大小:
“abcdef”==p1==p2==&(*p1)==&(*p2)
&arr1[0]==arr1
&arr2[0]==arr2
&p1!=&p2
内存图:
六、字符数组与字符串数组
上边写到了字符串数组,这里提一嘴字符数组与字符串数组。
和指针无关,可自行跳过。
1.sizeof与strlen
含义
sizeof()
是运算符,在头文件的类型为unsigned int
,其运算值在编译时就计算好了,参数可以是指针、数组、类型、对象和函数等;
strlen()
是函数,要在运行时才能计算。参数必须是字符型指针(char*)
。当数组名作为参数传入时,实际上数组就退化为指针了。该函数完成的功能是从代表该字符串的第一个地址开始遍历的,直到遇到结束符NULL。返回的长度大小不包括NULL。
示例一
#include #include //strlen要引头文件int main(){char str[20] = "hello";printf("strlen=%d\n", strlen(str));printf("sizeof=%d\n", sizeof(str));return 0;}
结果显示为:
strlen = 5sizeof = 20
这时的 strlen=5,sizeof=20
因为strlen
计算的是字符串的长度,以\0
为字符串结束标志;
而sizeof
计算的是分配的数组str[20]
所占的内存空间的大小,不受里面存储的内容影响。
示例二
#include int main(){char *str1 = "abcde";char str2[] = "abcde";char str3[8] = {'a'};char str4[] = "0123456789";printf("sizeof(str1)=%d\n", sizeof(*str1));printf("sizeof(str2)=%d\n", sizeof(str2));printf("sizeof(str3)=%d\n", sizeof(str3));printf("sizeof(str4)=%d\n", sizeof(str4));return 0;}
结果显示为:
sizeof(str1) = 4sizeof(str2) = 6 sizeof(str3) = 8 sizeof(str4) = 11
str1
是一个指针,只是指向了字符串"abcde"
而已。所以sizeof(*str1)
不是字符串占的空间,也不是字符数组占的空间,而是一个指针所占的空间。在C/C++中一个指针占四个字节。(32平台)
str2
是一个字符型数组,对于一个数组,返回这个数组所占的总空间,所以sizeof(str2)
取得的是字符串"abcde"
的总空间。"abcde"
中,共有a b c d e \0
六个字符,所以str2数组的长度时6。·
str3
已经定义成了长度为8的数组,所以sizeof(str3)
为8;
str4
和str2
类似,共十一个字符,所以str4
所占的空间是11.
说明
示例二里面列举了一个指针,如果你验证我的代码的话,可能会是sizeof(str1) = 8
那是因为32位机器上指针大小是4个字节,64位机器上是8个字节
因为32位机器的寻址地址空间是4G,每个地址是32位,恰好是4个字节。即指针大小是4个字节。
而64位机器的每个地址是64位,是8个字节,因此指针是8个字节。
代码三
子函数中,sizeof
会把从主函数中传进来的字符数组当作是指针来处理。
指针的大小又是由机器来决定,而不是人为的来决定的。
void size_of(char str[]){printf("sizeof = %d\n", sizeof(str));}int main(){char str[20] = "hello";size_of(str);return 0;}
结果显示为:
sizeof = 4
具体而言,当参数分别是如下时,sizeof返回的值表示的含义如下:
数组:编译时分配的数组空间的大小;
指针:存储该指针所用的空间的大小(存储该指针的地址的长度,是长整型,应该是4);
类型:该类型所占的空间的大小;
对象:对象的实际占用空间大小;
函数:函数的返回类型所占的空间大小。函数的返回类型不能是void。
代码四
#include #include int main(){char *str = "0123456789";printf("sizeof(str) = %d\n", sizeof(str));printf("sizeof(*str) = %d\n", sizeof(*str));printf("strlen(str) = %d\n", strlen(str));return 0;}
结果显示为:
sizeof(str) = 4sizeof(*str) = 1strlen(str) = 10
sizeof(str)
: str
是指向是字符串常量的字符指针,sizeof
获得的是第一个指针所占的空间,应该是长整型,所以是4;
sizeof(\*str)
: *str
是第一个字符,其实就是获得了字符串的第一位’0’
所占的内存空间,是char类型的,占了1位。
strlen(str)
:如果要获得这个字符串的长度,则一定要用strlen
。
总结
sizeof
是运算符,测量的是字符的分配大小
strlen
是函数,测量的是字符的实际长度,以\0
结束,所以只要strlen
碰到\0
就结束
2.字符数组与字符串数组
讲之前,我们还是先来回顾一下关于sizeof
和strlen
的用法
strlen
:
- 是一个库函数;
- 计算的是字符串的长度,并且只针对字符串;
- 关注的字符串中是否有
\0
,计算的是\0
之前的字符个数;
sizeof
:
- 是一个操作符(运算符);
sizeof
是用来计算变量所占内存空间大小的,任何类型都可以使用;- 只关注空间大小,不在乎内存中是否存在
\0
;
示例一
' '
:表示一个字符;
" "
:表示一个字符串;
- arr1里面的元素是字符,表示用字符初始化字符数组;
- arr2里面的元素是字符串,表示用字符串初始化字符数组;
#include int main(){char arr1[] = { 'a', 'b', 'c'};printf("%d\n", sizeof(arr1));char arr2[] = { "abc" };printf("%d\n", sizeof(arr2));return 0;}123456789101112
运行结果:
3412
解析:
sizeof
打印的是所占空间的大小
arr1里面的元素是:'a'
、'b'
、'c'
,所以大小就是3个字节
arr2里面的元素是:a
、b
、c
、\0
,所以大小就是4个字节
示例二
#include int main(){char arr1[] = { 'a', 'b', 'c'};printf("%d\n", strlen(arr1));char arr2[] = { "abc" };printf("%d\n", strlen(arr2));return 0;}123456789101112
运行结果:
15312
解析:
strlen
求字符串长度的时候,关注的是\0
;
arr1里面没有\0
,所以长度是未知的,是一个随机值15;
arr2里面有\0
,所以计算\0
前面的,也就是a
,b
,c
,所以长度为3;
总结
char arr1[] = { 'a', 'b', 'c' };//arr1有三个元素,数组的大小是3个字节;printf("%d\n", sizeof(arr1));printf("%d\n", strlen(arr1));//长度为随机值;char arr2[] = { "abc" };//arr2有四个元素,数组的大小是4个字节;printf("%d\n", sizeof(arr2));printf("%d\n", strlen(arr2));//长度为3;
参考文章:
【C语言深度剖析】深入理解字符数组和字符串数组_Albert Edison的博客-CSDN博客_c语言字符数组和字符串数组
(1条消息) 【C语言深度剖析】详解strlen与sizeof的区别及用法_Albert Edison的博客-CSDN博客
有什么问题,欢迎评论区留言。有时间看到我会回复。
如果有错误,欢迎指正。