【C语言】指针（详解）
文章目录
- 前言
- 1.字符指针
- 2. 指针数组
- 3. 数组指针
-
- 3.1 数组指针的定义
- 3.2 &数组名VS数组名
- 3.3 数组指针的使用
- 4. 数组参数、指针参数
-
- 4.1 一维数组传参
- 4.2 二维数组传参
- 4.3 一级指针传参
- 4.4 二级指针传参
- 5. 函数指针
- 6. 函数指针数组
- 7. 指向函数指针数组的指针
- 8. 回调函数
-
- 8.1 回调函数的概念
- 8.2 qsort函数的使用
- 8.3 用冒泡排序模拟实现qsort
- 9. 指针和数组笔试题解析
- 10. 指针笔试题
前言
在指针的简单了解这篇文章中，我们知道了指针的基本概念
- 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
- 指针的大小是固定的4/8个字节（32位平台/64位平台）。
- 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
- 指针的运算。
本文将继续深入探讨指针。
1.字符指针
在指针的类型中我们知道有一种指针类型为字符指针char*；
一般使用：
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
还有一种使用方式如下：
int main()
{
const char* pstr = "hello xiaobite.";//这里是把一个字符串放到pstr指针变量里了吗？
printf("%s\n", pstr);
return 0;
}
代码const char* pstr = "hello xiaobite.";
特别容易让我们以为是把字符串hello xiaobite.放到了字符指针pstr里了，但是本质是把字符串hello xiaobite.首字符的地址地址放到了pstr中。
上面代码的意思是把一个常量字符串的首字符h的地址存放到指针变量pstr中。
那就有这样一个题：
#include 这里是输出结果：
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。
2. 指针数组
指针数组顾名思义就是一个存放指针的数组。
在前面指针的简单了解这里我们也提到过，这里我们复习一下，下面的指针数组分别是什么意思？
int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组
3. 数组指针
3.1 数组指针的定义
数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。
下面代码哪个是数组指针？
int *p1[10]; //这是一个数组，里面有包含十个元素，每个元素的类型是int*
int (*p2)[10]; //这是一个指针，指向的类型是int [10]
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指
向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
3.2 &数组名VS数组名
对于下面的数组：
int arr[10];
arr和&arr分别是什么？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我看一段代码：
#include 运行结果如下：
可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：
#include 
根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。
实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
3.3 数组指针的使用
那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看代码：
#include ⭐️： 二维数组的每一行可以理解为二维数组的一个元素，而每一行又是一个一维数组。所以，二维数组其实是一维数组的数组。
一个数组指针的使用：
#include ：二维数组的数组名，也是数组名，数组名就是数组首元素的地址，而二维数组的首元素地址也就是第一行的地址，第一行是一个一维数组，所以我们传参时，应该使用一个存放该一维数组的指针来接收。
学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：
int arr[5]; //这是一个存放int类型的数组，大小为5
int *parr1[10]; //这是一个存放int*类型的数组，大小为10
int (*parr2)[10]; //这是一个指向类型为int [10]的指针
int (*parr3[10])[5]; //这时一个存放int* [5]类型的数组，大小为10
4. 数组参数、指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
4.1 一维数组传参
我们来看一下以下几种函数，哪些可以接收我们传的参数
#include 总结：数组传参，形参的部分可以是数组，也可以是指针。但其实本质上传过去的是地址，接收的是指针，写成数组的形式接收是为了方便初学者容易理解，但形参部分也不是真正的开辟了一片与该数组大小相同的空间，所以这也是为什么形参部分数组大小可以省略的原因。（这里值得注意的是，二维数组传参，行可以省略，但列不能省略，具体原因我们在下面分析）
4.2 二维数组传参
void test(int arr[3][5])//ok？
{}//该函数可以接收arr数组
void test(int arr[][])//ok？
{}//该函数不能接收arr数组
void test(int arr[][5])//ok？
{}//该函数可以接收arr数组
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？
{}//该函数不能接收arr数组
void test(int* arr[5])//ok？
{}//该函数不能接收arr数组
void test(int(*arr)[5])//ok？
{}//该函数可以接收arr数组
void test(int** arr)//ok？
{}//该函数不可以接受arr数组
int main()
{
int arr[3][5] = { 0 };
test(arr);
}
相信也有不少人刚学二维数组传参给一个函数的时候，也搞不清楚为什么二级指针或者指针数组不能够作为二维数组的形参，而数组指针才能够作为二维数组的形参，所以这里我们来解释一下吧：
- 因为数组的传参本质上是把地址给传过去，应该是用指针接收。而指针数组虽然可以用来模拟二维数组，但指针数组是一个数组，所以不能使用它来当形参接收二维数组。
- 在前面我们说到二维数组的数组名是它首元素的地址（也就是第一行的地址），而第一行是一个一维数组，即：
int(*p)[num]（这里的num代表一维数组的元素个数）才是指向二维数组的指针。而int** p不是指向二维数组，而是指向一个int型指针的指针
⭐️：因为数组传参的本质上是指针来接受，而这里是用一个数组指针int (*p)[num]接收，这里num不能省略，因为num表示的是一维数组元素的个数，num不同代表的类型也不同。这里也解释了为什么二维数组传参，行可以省略，但列不能省略了。
4.3 一级指针传参
#include 这串代码是将数组的首元素地址赋值给一个指针，随后将该指针传递进print函数中，在函数中对该指针指向的内容进行操作。
那么我们来思考一个问题：
void test1(int *p)
{}
//test1函数能接收什么参数？
void test2(char* p)
{}
//test2函数能接收什么参数？
test1函数的形参是一个整型指针，所以可以接收一个整型变量的地址，或者接收一个整型指针，或者接收是一个整型数组。
test2函数的形参是一个字符指针，所以可以接受一个字符变量的地址，或者接收一个字符指针，或者接收一个字符数组
4.4 二级指针传参
#include 那么我们开思考一个问题，当函数的参数为二级指针的时候，可以接收什么参数。
void test(char** p)
{
//...
}
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);//Ok?
return 0;
}
这里是否可以传char* arr[10]呢，答案是肯定的，因为char* arr[10]是一个数组，每个元素的类型是char*，而arr是数组名，代表的是首元素地址，而首元素也就是一个char*类型，也就是传过去的是char*的地址，所以应该使用char**来接收。
5. 函数指针
函数指针：顾名思义，就是指向一个函数的指针。
首先我们先来看一段代码：
#include 输出的结果：
⭐️：由此我们可以得出一个结论，函数名是函数的地址，&函数名也是函数的地址
输出的是两个地址，这两个地址是 test 函数的地址。 那我们的函数的地址要想保存起来，怎么保存？ 下面我们看代码：
void test()
{
printf("Hello world\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();
首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？ 答案是:
pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。
pfun2先和后面的()结合，所以pfun2是一个函数，返回类型为void*
我们来练习一下，给一个函数，让一个指针指向该函数，写出该指针的类型：
void test(char* p, int arr[10])
{
//...
}
int main()
{
//写法一:
void (*pf)(char*, int [10]) = &test;
//写法二:
void (*pf)(char*, int*) = &test;
return 0;
}
以上写法都是可以的，函数指针后面的括号里面只要加上类型就可以了，不用写变量名。写法二第二个参数类型可以写成
int*，原因是因为，数组在传参时本质上传递的是地址，所以应该用指针来接收，当然也可以写成数组的形式，这样是因为方便初学者能够理解，但在函数创建时，并不会重新开辟一片数组的空间。
那讲了怎么将函数存入到指针中，我们就来谈谈，这个指针可以怎么用，先看代码：
#include 执行结果如下：
当然，我们也可以讲代码写成这样：
#include 运行结果如下：
：我们将
Add直接存放在指针pf中了，那么这也就说明了Add和&Add都是函数Add的地址，所以我们不用对指针pf进行解引用就能直接使用了。所以我们使用指针pf时，就不用使用*了，这里的*就是一个摆设，加几个*都可以，但如果我们使用*时，一定要带括号，否则就会报错,。
阅读两段有趣的代码：
//代码1
(* (void (*)())0 )();
//代码2
void (*signal(int , void(*)(int)))(int);
首先我们要先知道，一个地址大概是这样一个形式：
0x010FFCEC，它表示的是一个地址（int*），但也可以表示一个整型（int），只不过他是十六进制表示的而已。
代码一：
0默认是一个整型类型，而我们强制类型转换成了一个void (*)()类型（这是一个函数指针类型，指向的是一个没有参数，返回类型是void的函数），那么就认为0地址处放有这个类型的函数，然后再对该函数进行解引用，调用0地址处的这个函数。
代码二：
这是一个函数声明，函数名是signal，第一个参数是int类型，第二个参数是void(*)(int)函数指针类型，而这个函数的返回类型是void(*)(int)函数指针类型。
我们可以简化这串代码，就方便理解了。我们可以将void(*)(int)类型重定义成pfun_t，那这时，就可以这样写：
typedef void (*pfun_t)(int); //这里是将void (*)(int)类型转换成pfun_t
pfun_t signal(int, pfun_t);
6. 函数指针数组
数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，比如：
int *arr[10];
//数组的每个元素是int*
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];
答案是：parr1 ；parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？ 是 int (*)() 类型的函数指针。
函数指针数组的用途：转移表
例子：（计算器）
我们在实现计算器的时候，大致思路是这样的：
#include 因为这几个函数的类型和参数都是一样的，所以我们也可以使用函数指针数组来完成：
#include 我们这样写，可以看到，代码大幅度的减少了，并且以后如果我们要增加其他的功能，也只用稍微修改一下代码就行了。
7. 指向函数指针数组的指针
指向函数指针数组的指针是一个指针指针指向一个 数组 ，数组的元素都是函数指针
如何定义？
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0;
}
⭐️：虽然说这些东西我们并不常见，但是这些也是语法支持的，在以后遇到的时候，我们应该学会去读懂这些复杂的代码。
如图，我们继续这样套娃下去都是可以的，但是也没必要了，这里大家就简单看看就行了，不用管是什么意思：
8. 回调函数
8.1 回调函数的概念
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
这里我们可以将前面的计算器代码改造一下：
#include 从这段代码中，我们可以看到它的调用逻辑是将add、sum、mul、div这几个函数的传参给Calc函数中去，而Calc函数中用int (*pfun_t)(int, int)接收这些函数，并在Calc函数中使用接收过来的函数。这就是回调函数。
8.2 qsort函数的使用
这里我们介绍一个函数qsort，并展示它的用法。点这里详细了解qsort。
由图，我们可以看到，qsort函数总的有四个参数，那我们就来聊一聊这四个参数分别代表什么意思：
void qsort(void* base, //指向我们要排序的数组的第一个元素
size_t num, //数组的元素个数
size_t size,//每个元素的大小0
int (*compar)(const void*, const void*));//函数指针类型 —— 这个函数指针指向的函数，能够比较base指向数组中的两个元素
//这个函数是由我们使用者自己去实现
我们再来看：这个比较函数是有两个参数,是有两个参数的，两个参数的类型如下：
int compar(cost void* p1, const void* p2)
⭐️：这两个参数中的指针指向的内容是要比较的两个元素的地址。
我们还注意到，这个比较函数，返回类型是int，具体是返回什么呢?
| 返回值 | 意思 |
|---|---|
| <0 | p1指向的元素小于p2指向的元素 |
| 0 | p1指向的元素等于p2指向的元素 |
| >0 | p1指向的元素大于p2指向的元素 |
⭐️： 这里我们来了解一下
void*指针：
这种类型的指针是不能直接进行解引用操作的
也不能直接进行指针运算的
void*指针，可以理解为无具体类型的指针，可以接收任意类型的地址
讲了那么多，那我们就先来测试一下qsort函数的一个使用吧，先看代码：
#include 效果如图所示：
当然，我们可以看到qsort函数的参数中的函数指针，它所指向的比较函数中的形参void*指针，而我们在上面讲了，void*指针可以指向任意类型的地址。所以我们知道，qsort函数可以排序任意类型，是不是这样呢？我们继续来测试一下：
#include 运行结果如下：
8.3 用冒泡排序模拟实现qsort
看到这里的人，想必大家对冒泡排序都不陌生，这里简单的给大家实现一遍：
void bubble_sort(int* arr, int sz)
{
assert(arr != NULL);//断言,不能将空指针传到该函数中
int i = 0;
for (i = 0;i < sz - 1;i++)
{
int j = 0;
int flag = 1;//做标记
for (j = 0;j < sz - 1 - i;j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
flag = 0;//如果一趟还没有排序完，就将标记置为0
}
}
//如果一趟下来没有发生变化，证明已经排序成果，不需要再继续排序
if (flag == 1)
break;
}
}
我们一般的实现逻辑是这样，但是可以看出，相较于qsort函数（我们暂且不考虑效率问题），我们这个能排序的类型就很局限了，只能排序int类型，而qsort函数我们经过上面的测试，可以看出它能够排序任意类型。那我们能否改造一下我们的冒泡排序，让它也能够排序任意类型呢？
当然是可以的，看代码：
#include 效果如图所示：
到这里，指针的基本内容也已经讲完了，接下来我们做点题巩固一下吧！
9. 指针和数组笔试题解析
⭐️：数组名的意义：
- sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
- &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
- 除此之外所有的数组名都表示首元素的地址。
第一题:
#include 
第二题：
#include 
第三题：
#include 
第四题：
#include 
第五题：
#include 
10. 指针笔试题
笔试题1：
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));
return 0;
}
//程序的结果是什么？
答案：
笔试题2：
//这里先告知该结构体大小为20个字节
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p = (struct Test*)0x100000;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}
答案：
笔试题3：
int main()
{
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int*)(&a + 1);
int* ptr2 = (int*)((int)a + 1);
printf("%x,%x", ptr1[-1], *ptr2);
return 0;
}
答案：
这里我们首先分析ptr1[-1]:
再分析ptr2之前，最好先了解一下大小端的概念，如果不了解，可以看看《数据的存储》这篇博客，了解的话可以直接看下面的解析：
笔试题4：
#include 答案：
笔试题5：
int main()
{
int a[5][5];
int(*p)[4];
p = a;
printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}
答案：
笔试题6：
int main()
{
int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int *ptr1 = (int *)(&aa + 1);
int *ptr2 = (int *)(*(aa + 1));
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
return 0;
}
答案：
笔试题7：
#include 
笔试题8：
int main()
{
char* c[] = { "ENTER","NEW","POINT","FIRST" };
char** cp[] = { c + 3,c + 2,c + 1,c };
char*** cpp = cp;
printf("%s\n", **++cpp);
printf("%s\n", *-- * ++cpp + 3);
printf("%s\n", *cpp[-2] + 3);
printf("%s\n", cpp[-1][-1] + 1);
return 0;
}
答案：
注： 这里尤其要注意的是我说的指向和访问两个词，
指向：表达一个指针指向哪里
访问：对某个地址进行解引用操作，访问该地址处的内容
