指针回顾：
1.指针是一个变量，用来存放地址。
2.指针大小是4或8个字节。
3.指针的类型决定了 指针的+-整数的步长，指针解引用操作的时候的权限。
一、字符指针
（1）存放字符
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'w';
return 0;
}?（2）存放字符串
int main()
{
??const char* ptr = "hello everybody";//还记得const是什么吗？它能否去掉呢？
??printf("%s\n", ptr);
??return 0;
}本质是把字符串? hello everybody 首字符的地址放到了指针变量ptr中。
（3）练习
#include <stdio.h>
int main()
{
char str1[] = "hello";
char str2[] = "hello";
const char* str3 = "hello";
const char* str4 = "hello";
if (str1 == str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if (str3 == str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}}最后会输出什么呢？
?原因：
str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。
但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。
所以str1和str2不同，str3和str4不同。
二、指针数组?
回顾：
1.指针数组是一个存放指针的数组
2.?还记得以下的指针数组什么意思吗？
int* a1[10]; //存放整形指针的数组
char* a2[4]; //存放一级字符指针的数组
char** a3[5];//存放二级字符指针的数组三、数组指针
（1）数组指针的定义
数组指针是指针
整形指针： int * pint; 能够指向整形数据的指针，存放整形的地址。?
浮点型指针： float * pf; 能够指向浮点型数据的指针，存放浮点型的地址。
那数组指针应该是：能够指向数组的指针，存放数组的地址。
看看谁是数组指针呢？p1, p2分别是什么？
int *p1[10];
int (*p2)[10];int *p1[10];
p1先和 [ ]结合，每个元素是 int* ，是存放指针的数组。
int (*p2)[10];定义，* 说明p2是指针，int* ?p2指向的数组类型是 int*。指针指向的数组，每个元素是int，p2指向的数组是5个元素的。
int (*p)[10];
解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
注意：[ ]的优先级高于?*?号，所以必须加上（）来保证p先和*结合（还记得常见符号优先级吗？
C语言基础知识了解一下：https://blog.csdn.net/MuqiuWhite/article/details/117587886
不过也可以记得加括号来保证结合优先性，代码可读性）
给你一个小技巧：
去掉名字，剩下的就是它的类型。
对于一个数组，去掉名字，[ ]，剩下的是它的每个元素的类型
?后面还会用这个小技巧哦，巩固加深印象！
（2）&数组名与数组名
对于下面的数组：
int a[10];arr 和 &arr 分别是啥？
arr是数组名，数组名表示数组首元素的地址。
那&arr数组名呢？
?我们看一段代码：
#include <stdio.h>
int main()
{
int a[10] = { 0 };
printf("%p\n", a);
printf("%p\n", &a);
return 0;
}
运行结果：
难道两个是一样的吗？?
我们再看一段代码：
#include <stdio.h>
int main()
{
int a[10] = { 0 };
printf("a = %p\n", a);
printf("&a= %p\n", &a);
printf("a+1 = %p\n", a + 1);
printf("&a+1= %p\n", &a + 1);
return 0;
}结果：?
?实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
?（3）数组指针的使用
#include <stdio.h>
int main()
{
??int a[10] = {1,2,3,4,5,6,7,8,9,0};
??int (*p)[10] = &a;//把数组a的地址赋值给数组指针变量p
??
??return 0;
}不过一般很少像上面这样写代码……
一个数组指针的使用：
#include <stdio.h>
void print_a1(int a[3][5], int row, int col)
{
int i = 0, j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", a[i][j]);
}
printf("\n");
}
}
void print_a2(int(*a)[5], int row, int col)
{
int i = 0, j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", a[i][j]);
}
printf("\n");
}
}
int main()
{
int a[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
print_a1(a, 3, 5);
print_a2(a, 3, 5);
return 0;
}解释：
void print_a1(int a[3][5], int row, int col)?
参数是数组
void print_arr2(int (*arr)[5], int row, int col)
参数是指针。
int (*arr)[5]是第一行元素。
指向数组的指针，i+1跳过一个数组，到了第二行?
数组名a，表示首元素的地址。
二维数组的首元素是二维数组的第一行 1 2 3 4 5
所以这里传递的a，其实相当于第一行的地址，是一维数组的地址可以数组指针来接收?
?值相等的不同表示方法：
*(a+i) == *(p+i) == a[i] == p[i] ?
*(*(p+i)+j) == (*(p+i)[j]) == p[i][j] == *(p[i]+j)
?结果：
?练习：
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];int arr[5];
a是一个五个元素的整形数组。
int *parr1[10];
p1 是一个数组，数组有10个元素，每个元素是int*，p1是一个指针数组。int (*parr2)[10];
p2 是一个指针，指向一个数组，数组有10个元素，每个元素类型为int，p2是数组指针。int (*parr3[10])[5];?
p3 是数组，先和[ ] 结合了。该数组有10个元素，每个元素是一个数组指针，数组指针指向的数组有5个元素，每个元素是int?
还记得刚刚的小技巧吗？
去掉p3[10],剩下的就是数组类型
?四、数组参数，指针参数
（1）一维度数组传参
?来看看下面的代码哪个是正确的呢？
#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr)//ok?
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);//一级指针的地址
return 0;
}?公布答案喽！
1.void test(int arr[])????????//√
2.void test(int arr[10])????????//√
3.void test(int* arr)????????//√
4.void test2(int* arr[20])????????//√
5.void test2(int** arr)????????//√
嘻嘻，都是对的！你答对了吗？
解释：
数组传参，写成数组，写成指针都行
[ ]数组大小可以省略，写不写，写错都行数组大小可以省略
（2）二维数组传参
void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
void test(int* arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int(*arr)[5])//ok？
{}
void test(int** arr)//ok？
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
}公布答案：
void test(int arr[3][5])????????//√
{}
void test(int arr[][])????????//×
{}
void test(int arr[][5])????????//√
{}
void test(int* arr)????????//×，一级指针
{}
void test(int* arr[5])????????//×，指针数组
{}
void test(int(*arr)[5])????????//√，数组指针
{}
void test(int** arr)????????//×，二级指针
{}int arr[3][5] = { 0 };? 首元素地址是第一行的地址，第一行是一维数组的地址
总结：
二维数组传参，函数形参的设计只能省略第一个[]的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
（3）一级指针传参
#include <stdio.h>
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d\n", *(p + i));
}
}
int main()
{
int a[6] = { 1,2,3,4,5 };
int* p = arr;
int sz = sizeof(arr) / sizeof(a[0]);
//一级指针p，传给函数
print(p, sz);
return 0;
}当函数参数部分为一级指针时，接受什么参数呢？
地址，存放地址的一级指针
?再比如：
void test1(int* p)
{}
void test2(char* p)
{}
test1函数能接收什么参数？
int a=10;
test1(&a);?
int *p=&a;
test1(p);?
test2函数能接收什么参数？
把上面的代码中的 int?换成char
?（4）二级指针传参
示例：?
#include <stdio.h>
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int* p = &n;
int** pp = &p;
test(pp);
test(&p);
return 0;
}
所以二级指针为函数参数时，又可以接收什么参数呢？
void test(char** p)
{
}
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char* arr[10];
test(&pc);//一级指针的地址
test(ppc);//二级指针
test(arr);//指针数组的一级指针地址，指针数组传参
return 0;
}
五、函数指针
指向函数的指针——存放函数地址的指针?
返回类型 （*函数指针名）（参数类型，）=函数名?
调用：（*函数指针名）（传参，）这里的*可以去掉
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}&函数名和函数名都是函数的地址 ?
结果：
输出的是两个地址，这两个地址是 test 函数的地址。 那我们的函数的地址要想保存起来该怎么办呢？
void test()
{
printf("hehe\n");
}下面pfun1和pfun2，谁能存放test函数的地址？
void (*pfun1)();? ?√pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。
void *pfun2();??pfun2是函数名，先于括号结合，是函数声明，没有函数参数，返回值为void
再比如：
int add(int x,int y)
{
z=x+y;
return z;
}
int main()
{
int (*pa)(int,int)=add;//也可以不带*
printf("%d",(*pa)(2,3));
}printf("%d",(*pa)(2,3));? ?解引用
pa(2,3);??调用指针所指的函数的地址
?有两段代码，来看看它们有多有趣吧！
//1
(*(void (*)())0)();
//2
void (*signal(int, void(*)(int)))(int);
//1
(*(void (*)())0)();?void (*)()函数指针类型,在括号里放一个类型，强制类型转换把0，从int转换为函数的地址。
0就是一个函数的地址，调用0地址处的该函数。
*，找这个函数。无参数，返回类型void。
//2
void (*signal(int, void(*)(int)))(int);函数指针类型，函数参数int，返回值void
函数名signal
void (* ? ?)(int):函数指针—signal的返回类型
代码2如何简化呢？
typedef void(*pt)(int);
signal是一个函数声明。函数参数有两个，第一个是int,第二个是函数指针，该函数指针指向的函数的参数是Int，返回值是void。
pt signal(int, pfun_t);signal函数的返回类型也是一个函数指针，该函数指针指向的函数的参数是int，返回值的类型void
六、函数指针数组
指针数组：int *arr[10];
数组的每个元素是int*
?（1）定义
保存函数指针的数组，函数的地址存到一个数组中，这个数组就叫函数指针数组
int (*parr1[10]])();? √
int *parr2[10]();
int (*)() parr3[10];
还记得之前的小技巧吗？
int (*parr1[10])();
把parr1[10]去掉，剩下的?int (*)(?参数类型 )?是函数类型。
（2）函数指针数组的用途：转移表
一个简单的计算器！
#include <stdio.h>
int add(int a, int b)//加
{
return a + b;
}
int sub(int a, int b)//减
{
return a - b;
}
int mul(int a, int b)//乘
{
return a * b;
}
int div(int a, int b)//除
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int r = 0;
int(*p[5])(int x, int y) = { 0, add, sub, mul, div };
while (input)
{
printf("*************************\n");
printf(" 1:add ?????2:sub \n");
printf(" 3:mul ?????4:div \n");
printf("*************************\n");
printf("选择:>");
scanf("%d", &input);
if ((input <= 4 && input >= 1))
{
printf("输入操作数：");
scanf("%d %d", &x, &y);
r = (*p[input])(x, y);
}
else
printf("输入有误\n");
printf("r = %d\n", r);
}
return 0;
}
七、指向函数指针数组的指针
指向函数指针数组的指针是一个 指针，?指针指向一个 数组 ，数组的元素都是 函数指针?
定义方法：
还记得前面的函数指针吗？
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pf
void (*pf)(const char*) = test;
//函数指针的数组pp
void (*pfArr[5])(const char* str);
pfArr[0] = test;
//指向函数指针数组pfArr的指针ppfArr
void (*(*ppfArr)[10])(const char*) = &pfArr;
return 0;
}八、回调函数
（1）定义
回调函数就是一个通过函数指针调用的函数。如果把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，就称这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
?
?
（2）qsort() 函数的使用
函数的声明?
void qsort(void* p, size_t n, size_t size, int (*compare)(const void*, const void*))?
p:?要排序的数组的第一个元素的指针
n: 由p指针指向的数组的元素的个数
size: 数组中每个元素的大小，以字节为单位
compare:?由使用者自己实现的?比较两个元素的函数
返回值：无
?
#include <stdio.h>
#include <stdlib.h> //qsort()需要的头文件
//要实现一个比较函数
int int_cmp(const void* p1, const void* p2)
{
return (*(int*)p1 - *(int*)p2);//void强制转换成int
}
int main()
{
int arr[] = { 1, 3, 4, 6, 8, 0，5, 7, 9, 2 };
int i = 0;
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}上诉代码实现的是升序：
p1 > p2，? ??? ?输出>0的数;
p1?< p2，? ? ? ?输出<0的数;
p1?= p2，? ? ? ?输出? 0；要实现降序：
则p2-p1
（3）模拟实现qsort()函数
?九、指针和数组笔试题详解
（1）一维数组
int a[] = {1,2,3,4};?
1.
printf("%d\n",sizeof(a));
sizeof(数组名)--数组，计算数组的大小；单位为字节 ?16
2.
printf("%d\n",sizeof(a+0));
首元素地址，计算首元素地址大小 4/8字节
3.
printf("%d\n",sizeof(*a));
解引用首元素，a[0]大小是4，*a==*(a+0)==a[0]
4.
printf("%d\n",sizeof(a+1));a[1]的地址，4/8
5.
printf("%d\n",sizeof(a[1]));a[1]? ?4字节
6.
printf("%d\n",sizeof(&a));&数组名--数组，数组的地址 ?4/8 ，用 int (*)[4] （还记得它是什么吗？）
7.
printf("%d\n",sizeof(*&a));解引用数组的地址，是数组，大小为16，a=*&a?
8.
printf("%d\n",sizeof(&a+1));数组的地址+1，跳过整个数组，还是地址，4/8
9.
printf("%d\n",sizeof(&a[0]));地址，4/8
10.
printf("%d\n",sizeof(&a[0]+1));第二个元素的地址，4/8
?
?（2）字符数组
char arr[] = {'a','b','c','d','e','f'};
1.
printf("%d\n", sizeof(arr));?6
2.
printf("%d\n", sizeof(arr+0));首元素的地址，4/8
3.
printf("%d\n", sizeof(*arr));首元素地址，解引用，首元素1字节
4.
printf("%d\n", sizeof(arr[1]));首元素 ，1字节
5.
printf("%d\n", sizeof(&arr));
整个数组的地址，4/8
6.
printf("%d\n", sizeof(&arr+1));跳过一个数组，f后面的地址，4/8
7.
printf("%d\n", sizeof(&arr[0]+1));跳过一个字符，b的地址，4/8
8.
printf("%d\n", strlen(arr));随机值
9.
printf("%d\n", strlen(arr+0));随机值
10.
printf("%d\n", strlen(*arr));报错，把‘a’的ASCII码值? 97? 当做地址。*arr不是地址。
回顾一下strlen的声明：size_t strlen(const char *str)
11.?
printf("%d\n", strlen(arr[1]));
‘b’,从98这个地址寻找\0，报错
12.
printf("%d\n", strlen(&arr));
会自动把&a这个数组指针，转为char*,strlen得到'a'的地址，随机值
13.
printf("%d\n", strlen(&arr+1));从f后面找，随机值
14.
printf("%d\n", strlen(&arr[0]+1));从b开始找，随机值，比从a找少1字节?
补充一点：
11. printf("%d\n", strlen(arr[1]));
13. printf("%d\n", strlen(&arr+1));
这两个随机值之间差了6字节，不信的话可以自己运行以下代码哦！
?
?
char arr[] = "abcdef";
?
1.
printf("%d\n", sizeof(arr));7
2.
printf("%d\n", sizeof(arr+0));首元素地址，4/8
3.
printf("%d\n", sizeof(*arr));首元素，1
4.
printf("%d\n", sizeof(arr[1]));首元素，1
5.
printf("%d\n", sizeof(&arr));数组的地址，4/8
6.
printf("%d\n", sizeof(&arr+1));跳过整个数组后的地址，4/8
7.
printf("%d\n", sizeof(&arr[0]+1));第二个元素的地址，4/8
?
8.
printf("%d\n", strlen(arr));6
9.
printf("%d\n", strlen(arr+0));首元素的地址，6
10.
printf("%d\n", strlen(*arr));报错，把97当做地址
11.
printf("%d\n", strlen(arr[1]));报错，98当做地址
12.
printf("%d\n", strlen(&arr));当做 ‘a’ 的地址，6
13.
printf("%d\n", strlen(&arr+1));跳过整个数组，随机值
14.
printf("%d\n", strlen(&arr[0]+1));第二个元素的地址，b
?
?
char *p = "abcdef";
?
1.
printf("%d\n", sizeof(p));指针大小，4/8
2.
printf("%d\n", sizeof(p+1));第二个元素的地址，4/8
3.
printf("%d\n", sizeof(*p));第一个元素a，1
4.
printf("%d\n", sizeof(p[0]));首元素a，1
5.
printf("%d\n", sizeof(&p));指针p的地址，4/8
6.
printf("%d\n", sizeof(&p+1));跳过一个数组后的地址，4/8
7.
printf("%d\n", sizeof(&p[0]+1));第二个元素的地址，4/8
?
8.
printf("%d\n", strlen(p));数组的地址，6
9.
printf("%d\n", strlen(p+1));第二个元素的地址开始，5
10.
printf("%d\n", strlen(*p));首元素，不是地址，报错
11.
printf("%d\n", strlen(p[0]));==*p，报错
12.
printf("%d\n", strlen(&p));指针的地址，随机值
13.
printf("%d\n", strlen(&p+1));指针地址+1，随机值，和上面的12题的结果没有关系，因为不确定\0在哪
14.
printf("%d\n", strlen(&p[0]+1));首元素地址+1，第二个元素的地址开始，5
（3）二维数组
?
欢迎各位在评论区和博主友好交流！感谢点赞、评论、收藏、关注！
C语言笔记系列持续更新中……