文章目录

  • 一、回顾
  • 二、字符指针
    • 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”?

我们创建了两个数组,arr1arr2,它们在内存中一定是有两块空间的,两个数组的数组名当然是两个不同的首元素地址了。

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;

str4str2类似,共十一个字符,所以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.字符数组与字符串数组

讲之前,我们还是先来回顾一下关于sizeofstrlen的用法

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里面的元素是:abc\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前面的,也就是abc,所以长度为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博客

有什么问题,欢迎评论区留言。有时间看到我会回复。
如果有错误,欢迎指正。