初识指针结束啦，从本期开始，正式进入指针进阶部分。
目录
一、字符指针
二、数组指针
回顾关于数组名的理解
一、字符指针
在指针的类型中，我们知道有一种指针类型为字符指针char*
思考以下代码的输出：
int main()
{
char c = 'b';
char* pc = &c;
*pc = 'd';
printf("%cn", c);
return 0;
}
正确输出结果为：d
分析:
我们将变量c的地址存放在指针pc里面,后续通过解引用就可以找到变量c，然后给其赋值为字符d，因此后面打印结果就是d咯！
再来看如下代码，思考其输出结果：
int main()
{
char* p = "lyjlyj";//把字符串首字符的地址，赋值给了p
printf("%sn", p);
p = "abcd";
printf("%sn", p);
*p = "abcd";
printf("%sn", p);
return 0;
}
正确输出结果：
（1）：lyjlyj
（2）：abcd
（3）：报错
第一个输出，毋庸置疑，通过指针p，就可以找到其字符串的地址，然后打印出来
第二个输出，因为p是一个变量，比如，int a=1,我们可以给变量再赋值为a=2，
所以在这里，我们是将字符串首字符的地址赋值给p，后续当然可以给变量赋其他值了，在上述代码中，我们就将字符串abcd的首字符a的地址赋值给了p。
第三个输出，错误。 我们在这里是通过给指针解引用，找到p所指向的地址，将其地址里面的内容进行修改，但是因为“lyjlyj”，是常量字符串，而常量字符串不可以修改的，而你强行修改它，虽然编译器不会报错（因为p确实敢去改“lyjlyj”这个字符串的首字符地址），但是在运行时，编译器就会挂掉。
所以我们可以将代码修改如下：
const char* p = "lyjlyj";
在这里加上一个const来修饰，你想修改？编译器会直接报错，就可以有效地保护了后面的字符串。
下面来看一道笔试题：
int main()
{
const char* p1 = "abcdef";
const char* p2 = "abcdef";
char arr1[] = "abcdef";
char arr2[] = "abcdef";
if (p1 == p2)
printf("p1 == p2n");
else
printf("p1!=p2n");
if (arr1 == arr2)
printf("arr1==arr2n");
else
printf("arr1!=arr2n");
return 0;
}
思考一下，输出什么呢？
输出结果：
分析：
p1和p2指针变量里面存放的都是字符串“abcdef”，而这个字符串它是常量字符串，放在内存的只读数据区里面的，既然是在只读数据区，并且不能更改，那我们在里面存放一份就够了，大家都不能改它，需要时，拿来用即可！所以也就是说，p1和p2是指向同一个常量字符串，C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个常量字符串时，他们实际是指向同一块内存，p1和p2所指向的是同一个地址，所以p1=p2
arr1和arr2是两个不同的数组，分别给“abcdef”给arr1和arr2初始化为相应字符串，不管初始化内容是什么，两个不同的数组在内存中就会开辟不同的空间，其地址自然是不可能相同的。
二、数组指针
数组指针：主语是指针。
回顾：
整型指针——>是指向整形的指针
字符指针——>是指向字符的指针
类比过来，因此，数组指针，是指向数组的指针
查看如下代码：
int* p1[10]; int (*p2)[10];
思考p1,p2分别是什么呢？
根据优先级来看，p1是先和[ ]结合，所以p1是一个数组，是一个指针数组，数组里面的每个元素是整型指针。
根据优先级来看，p2是先和*号结合，所以p2是一个指针，是一个数组指针，指针所指向的是含有10个元素的整型数组
回顾关于数组名的理解：
int a[10] = { 0 };
printf("%pn",a);
printf("%pn", &a[0]);
注：%p是打印地址的意思
思考输出结果是否相等呢？
结果：是相等的。
因为在这里，数组名就是数组首元素的地址（有2个例外）
数组名通常表示的都是数组首元素的第地址
有2个例外：
1、sizeof(数组名），这里的数组名表示整个数组，计算的是整个数组的大小（单位：字节）
注意：在这里是在括号里面是单独放了一个数组名，例如sizeof(a+0)就不能认为是单独放了一个数组名
2、&数组名，这里的数组名表示的是整个数组，所以&数组名取出的是整个数组的地址
看代码：
printf("%pn",a);
printf("%pn", &a[0]);
printf("%pn", &a);
这里打印时，从值的角度来讲，输出的结果是相同的。
下面来看区别是什么呢？
printf("%pn",a);
printf("%pn", a + 1);
printf("%pn", &a[0]);
printf("%pn", &a[0] + 1);
printf("%pn", &a);
printf("%pn", &a + 1);
运行结果：
这里的地址编号使用的是十六进制数来表示的。
当a加一时，a表示数组首元素地址，则跳过一个整型空间的大小，即加4；
当&a[0]加一，也跳过一个整型空间的大小，加4；
当&a+1时，因为&a是取出整个数组的地址，所以加一，跳过一个数组的大小，这里的数组就是40个字节，即加40（计算时注意进制转换）
思考：
p=&a;——>a是数组名，那p的类型应该怎么写才对呢？
正确答案：数组指针
即：
int a[10] = { 0 };
int(*p)[10] = &a;
注：这里不是二级指针，再次强调，二级指针是存放一级指针变量的地址。
例1：
char b[5] = { 0 };
char (*pb)[5] = &b;
注：（*pb)后面的[ ]里面的数字不能丢
例2：
int main()
{
int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
int(*p)[10] = &a;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", ( * p)[i]);//*p——>相当于数组名a
}
return 0;
}
这种用法原则上是没有问题的，但是我们会发现，反而把代码复杂化了，所以一般情况下，不是这么用的。
正确用法：（一般都会使用在多维数组里）
void print1(int a[3][5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
printf("%d ", a[i][j]);
}
printf("n");
}
}
void print2(int(*p)[5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
//写法一：
//printf("%d ", p[i][j]);
//写法二：
//printf("%d ", *(*(p + i)+j);
//写法三：
printf("%d ", (*(p + i))[j]);
}
printf("n");
}
}
int main()
{
int a[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
print1(a, 3, 5);
print2(a, 3, 5);
return 0;
}
观察print1和print2会发现他们的最终实现的结果是一样的，区别在于，print1中是用a[3][5]接收，print2是利用数组指针接收。因为二维数组的数组名表示首元素地址，即第一行的地址，而第一行相当于一个一维数组，即相当于一个一维数组的地址，所以采用数组指针接收。
p+i表示第i的地址，*(p+i)对第i行解引用，就是拿到这一行，即这一行的一维数组的数组名，即这一行的首元素的地址，再+j，后解引用，即拿到相应的元素。
实际上，你利用print1中的a[3][5]时，系统在计算时，还是利用*(*(p + i)+j)这种来计算的。
分析下列代码：
int a1[5];
int* a2[10];
int(*a3)[10];
int(*a4[10])[5];
a1是一个数组，存放5个int型的数据的数组
a2是一个指针数组，存放5个int* 型的指针变量的数组
a3是一个数组指针，指针所指向的是含有10个int数据的数组
a4是一个数组指针数组，存放数组指针的数组。（该数组是存放5个指针变量的数组，每个指针变量又是指向含有5个int型元素的数组）
a1是一个数组，存放5个int型的数据的数组
a2是一个指针数组，存放5个int* 型的指针变量的数组
a3是一个数组指针，指针所指向的是含有10个int数据的数组
a4是一个数组指针数组，存放数组指针的数组。（该数组是存放5个指针变量的数组，每个指针变量又是指向含有5个int型元素的数组）
