一、回顾
指针的主题，我们在(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'; //字符变量ch
char* pc=&ch; //将字符变量ch的地址取出来，存在pc中。pc就被称为字符指针，类型就是char*
字符指针是一个指针变量，里面存放一个字符的地址。
将字符指针解引用，可以找到字符。
*pc = 'w';
2.误区
（1）字符指针存放字符串首元素地址
看如下代码：
int main(){
char* pstr="hello";
printf("%s\n",pstr);
return 0;
}
看第一行代码。
:question: 这里，是把一个字符串"hello"存放到pstr指针变量里面了吗？
:red_car:注意
代码char* pstr="hello";，
特别容易让我们以为是把字符串hello放到了字符指针pstr里面。
但本质是把字符串hello的首字母地址存放到了pstr中。
其实一般这里有两种理解：
第一种理解是错误的！
第二种理解是正确的。a的地址赋值给了p。（常量字符串有什么需要注意的地方，后边讲解。）
可以输出看一下，p指针解引用之后的结果：
输出结果是a， p里面存放的是a的地址！
再想一个问题：
既然p里面存放的是a的地址，那么如果打印的话，是否能打印出来abcdef呢？
不妨试一下：
printf("%s\n",p);
:cake:总结
将字符串赋值给一个字符指针变量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就停止打印，所以就可以打印出来整个字符串。
:book:补充
有的小伙伴可能不太理解为何打印整个字符串，这里解释一下：
打印一个字符，用%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（段错误）的错误。
写入访问权限冲突，访问非法内存。
:oncoming_automobile:号外
当时在栈溢出的时候介绍了一个网站:
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;
}
这个面试题输出结果是多少呢？
看一下：
:question: 为什么结果是“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;
}
打印输出看一下：
:question: 现在打印的结果为啥是“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
int main()
{
char str[20] = "hello";
printf("strlen=%d\n", strlen(str));
printf("sizeof=%d\n", sizeof(str));
return 0;
}
结果显示为：
strlen = 5
sizeof = 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) = 4
sizeof(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) = 4
sizeof(*str) = 1
strlen(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
运行结果：
3
4
12
解析：
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
运行结果：
15
3
12
解析：
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；
:bookmark_tabs: 参考文章：
【C语言深度剖析】深入理解字符数组和字符串数组_Albert Edison的博客-CSDN博客_c语言字符数组和字符串数组
(1条消息) 【C语言深度剖析】详解strlen与sizeof的区别及用法_Albert Edison的博客-CSDN博客
有什么问题，欢迎评论区留言。有时间看到我会回复。如果有错误，欢迎指正。