C语言指针超详解——最终篇一

🕗 发布于 2024-07-21 22:10 c语言 开发语言 c++ 算法

C语言指针系列文章目录

入门篇
 强化篇
 进阶篇
 最终篇一

文章目录

C语言指针系列文章目录
1. 回调函数是什么
2. qsort 函数
3. 模拟实现 qsort 函数
4. sizeof 与 strlen 的对比
5. 数组和指针笔试题解析
- 5.1 一维数组
- 5.2 字符数组

由于最终篇内容较多，所以拆分成两篇。

1. 回调函数是什么

回调函数就是一个通过函数指针调用的函数。
如果你把函数的指针(地址)作为参数传递给另个函数，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数。

上一篇博客我们写的计算器的实现的代码中，main 函数的许多代码是重复出现的，其中虽然执行计算的逻辑是有一些区别的，但是输入输出操作是冗余的，然后我们利用转移表进行了简化。
有没有其他的简化思路呢？

因为红色框中的代码，只有调用函数的逻辑是有差异的，我们可以把调用的函数的地址以参数的形式传递过去，使用函数指针接收，函数指针指向什么函数就调用什么函数，这里其实使用的就是回调函数的功能。

未改造的计算器
（这个代码太过臃肿，所以图片展示，如果需要这段代码可以在我的指针系列的上一篇博客中获取）

//使用回到函数改造后
#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;
}
void calc(int(*pf)(int, int))//看一看这个函数，它的参数是一个函数指针，而且这个函数指针的
{ //类型恰好和上面的4个计算用的函数类型相同
int ret = 0;
int x, y;
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = pf(x, y);//调用 calc 函数，会调用传参过来的函数，这就是回调函数
printf("ret = %d\n", ret);
}
int main()
{
int input = 1;
do
{
printf("*************************\n");
printf("1:add 2:sub \n");
printf("3:mul 4:div \n");
printf("*************************\n");
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
calc(add);//这里调用 calc 函数实际上是是在通过 calc 函数调用其他的函数
break;
case 2:
calc(sub);
break;
case 3:
calc(mul);
break;
case 4:
calc(div);
break;
case 0: printf("退出程序\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}

像上面这样的给一个函数传过去一个函数指针的地址来进行函数实现的，就叫做回调函数。

2. qsort 函数

2.1 概念

qsort 函数是一个用来排序的库函数，我们来看看cplusplus上对于这个函数的介绍：
参数部分

可以看到

void qsort(void* base, size_t num, size_t size,
    int (*compar)(const void*, const void*));

qosrt 是一个没有返回类型的函数，它有4个参数，分别是：

  void* base  ---- 需要排序的数据的首地址，注意需要被排序的元素的地址必须是连续的
  size_t num  ---- 需要排序的数据个数
  size_t size ---- 需要排序的数据每个数据的大小，单位为字节
  int(*compare)(const void*,const void*) ---
  一个返回类型为 int 的函数指针，两个参数的类型都是 const void*

我想你可能已经猜出来 qosrt 排序的原理了，没错，就是根据 size 的大小去解引用 base 指向的数据，然后调用 compare 函数比较两个数据的大小，根据其返回结果按照字节依次将两个数据中的数据进行交换（也就是交换内存中这两个数据的每个字节存储的数据）。

有了这样的推理，我们就只需要再关心一下 compare 函数怎么构建就可以了，我们再来看cplusplus上对于 compare 函数的介绍：
compare
返回值：

如果前面的元素比后面的元素大，返回一个大于0的数字
如果前面的元素比后面的元素小，返回一个小于0的数字
如果前面的元素和后面的元素相等，返回0

参数：
参数为两个 void* 的指针，值得注意的是 void* 类型的指针是无法直接解引用的，所以在函数内部对 p1，p2 进行解引用操作之前，需要先进行强制类型转换。

2.2 qsort 排序 int 类型数据

代码示例：

#include<stdio.h>
#include<stdlib.h>//注意 qsort 函数包含在这个头文件中

int int_cmp(const void* p1, const void* p2)
{
return *(int*)p1 - *(int*)p2;//这个代码首先对 p1 和 p2 进行了强制类型转换，然后解引用
}

int main()
{
int arr[] = { 9,8,7,6,5,4,3,2,1 }; //注意，qsort 排序的结果默认是升序的，
size_t sz = sizeof(arr) / sizeof(arr[0]);//所以我们先用一个降序的数组做测试

qsort(arr, sz, sizeof(arr[0]), int_cmp);//使用 qsort 进行排序
//这里的 sz 就是数据的个数， sizeof(arr[0]) 就是每个数据的大小
for (int i = 0; i < sz;i++)//打印一下
printf("%d ", arr[i]);
printf("\n");
return 0;
}

输出结果：
qsort

我们再来看看 int_cmp 这个函数：
这个函数接受了两个 void* 的指针，但是我们在设计这个函数的时候已经知道了这个函数会接受的指针实际指向的类型，所以我们可以直接将这两个参数强制类型转换为 int* 类型的变量，然后按照要求设计返回值，在返回时，除了上面的做法，还有一种写法：

int int_cmp(const void* p1, const void* p2)
{
if (*(int*)p1 > *(int*)p2)
return 1;
else if (*(int*)p1 < *(int*)p2)
return -1;
else
return 0;
}

也就是说，这个函数只要符合要求，怎么写都是可以的。

注释中提到： qsort 函数排序默认是升序，那么有没有办法让它排成降序的呢？当然有，只需要修改一下 compare 函数的返回值的正负就可以了：

int int_cmp(const void* p1, const void* p2)
{
return *(int*)p2 - *(int*)p1;//这里 p1 和 p2 调换了位置
}

将 int_cmp 函数修改为这样，那么 qsort 函数排出来的就是降序的了。

2.3 使用 qsort 排序结构体数据

qosrt 并不只能用来排序 int , char 类型的数据，它还能用来排序结构数据。

不过在测试之前，我们先来了解一个库函数：strcmp

int strcmp(const char* str1, const char* str2);

这是一个包含在 <string.h>库中的库函数，用来比较两个字符串是否相同，
如果相同，它将返回0，
如果不相同，它将返回两个字符串中第一个不相同的位置的两个数据的差（str1 - str2）(当然一些编译器并不是这么实现的，以后的博客会对这个库函数进行详细的介绍，现在这么理解就可以了)。

有了这个函数，我们就来尝试一下实现 qsort 排序结构体数据吧：

#include<stdio.h>
#include<stdlib.h>//注意 qsort 函数包含在这个头文件中
#include<string.h>// strcmp 包含在这个头文件中
typedef struct stu
{
char name[10];
int age;
}stu;//想一想，stu 结构体中有两个成员，我们要用哪一个来排序呢？

int age_cmp(const void* p1, const void* p2)
{//按年龄排序
return ((stu*)p1)->age - ((stu*)p2)->age;
}

int name_cmp(const void* p1, const void* p2)
{//按名字排序
return strcmp(((stu*)p1)->name, ((stu*)p1)->name);
}

void Print(stu* s,size_t sz)
{//这个函数用来打印结构体，方便我们观察
static int time = 1;//还记得 static 修饰局部变量吗，不记得的话可以看一下我的函数基础知识的博客
printf("第%d次\n", time++);
for (int i = 0; i < sz; i++)
{
printf("%s %d\n", s[i].name, s[i].age);
}
}

int main()
{
stu s[] = { {"zhangsan", 15}, {"lisi", 30}, {"wangwu", 20} };//创建一个 stu 数组并初始化
size_t sz = sizeof(s) / sizeof(s[0]);
Print(s, sz);

qsort(s, sz, sizeof(s[0]), age_cmp);//先根据年龄排序一下
Print(s, sz);

qsort(s, sz, sizeof(s[0]), name_cmp);//再根据名字排序一下
Print(s, sz);

return 0;
}

输出结果为：

这就是 qsort 函数的一个优势，无论存储的是什么类型的元素，只要给出它的大小，数量，再设计一个比大小的函数，就能实现排序。

3. 模拟实现 qsort 函数

为了简单起见，我们使用冒泡排序模拟实现这个 qsort 函数。
（如果你不了解冒泡排序，可以看看指针强化篇这篇博客）

想一想我们需要什么？
我们再来看一看 qsort 的声明：

void qsort(void* base, size_t num, size_t size,
    int (*compar)(const void*, const void*));

还有我们前面分析出来的 qsort 的原理：根据 size 的大小去解引用 base 后的数据，然后调用 compare 函数比较两个数据的大小，根据其返回结果按照字节依次将两个数据中的数据进行交换（也就是交换内存中这两个数据的每个字节存储的数据）。
那么我们需要做的就是实现遍历，比较，交换这三个过程，我们来试一试：

void my_qsort(void* arr, size_t ElementNum, size_t ElementSize, int (*cmp)(const void*, const void*))
{
for (int i = 0; i < ElementNum - 1; i ++)
{
for (int j = 0; j < ElementNum - i - 1; j ++)
{//使用冒泡排序算法的思路进行数据遍历
if (cmp((char*)arr + j * ElementSize, (char*)arr + (j + 1) * ElementSize) > 0)
{//如果 cmp 函数的返回值大于 0 ，就说明这两个数据的顺序与最终结果不匹配，进行交换
for (int k = 0; k < ElementSize; k++)
{//在内存中进行每个字节的数据的交换，那么 char 类型就正好可以满足这个任务
char tmp = *((char*)arr +  j * ElementSize + k);
*((char*)arr + j * ElementSize + k) = *((char*)arr + j * ElementSize + ElementSize + k);
*((char*)arr + j * ElementSize + ElementSize + k) = tmp;
//上面这三行代码实际上就是交换两个 char 类型的数据，只不过由于是 void* 类型，需要不断地强制转换，所以显得麻烦  
//如果你不希望这个函数看起来这么臃肿，可以把交换数据的这段代码封装为函数
}
}
}
}
}

这个代码就可以完成 qsort 函数的工作，但是要注意，由于我们使用的是冒泡排序，时间复杂度为O(n²)，所以在处理特别多的数据时可能会耗费大量的时间。

4. sizeof 与 strlen 的对比

4.1 sizeof

在操作符的博客中，我们学习了 sizeof 这个操作符，sizeof 计算变量所占内存内存空间大小的，单位是字节，如果操作数是类型的话，计算的是使用类型创建的变量所占内存空间的大小。
sizeof 只关注占用内存空间的大小，不在乎内存中存放什么数据。
比如：

#include <stdio.h>
int main()
{
int a = 10;
printf("%d\n", sizeof(a));//40
printf("%d\n", sizeof a);// 40 ,sizeof 计算变量大小时，可以省略括号
printf("%d\n", sizeof(int));//4

return 0;
}

4.2 strlen

strlen 是<string.h>中的库函数，功能是求字符串长度。函数原型如下：

size_t strlen ( const char * str );

统计的是从 strlen 函数的参数 str 中这个地址开始向后，\0 之前字符串中字符的个数。
strlen 函数会一直向后找 \0 字符，直到找到为止，所以可能存在越界查找。

#include <stdio.h>
int main()
{
char arr1[3] = { 'a', 'b', 'c' };//arr1 后面没有 \0
char arr2[] = "abc"; //arr2 后面有 \0
printf("%d\n", strlen(arr1));//随机
printf("%d\n", strlen(arr2));//3

printf("%d\n", sizeof(arr1));//3
printf("%d\n", sizeof(arr2));//4
return 0;
}

4.3 sizeof 与 strlen 的对比

sizeof	strlen
sizeof是操作符	strlen是库函数
sizeof计算操作数所占内存的大小，单位是字节	srtlen是求字符串长度的，统计的是、0之前字符的个数
不关注内存中存放什么数据	关注内存中是否有\0，如果没有\0，就会持续往后找，可能会越界

5. 数组和指针笔试题解析

注：以下分析均以 x64 环境分析

5.1 一维数组

#include<stdio.h>
int main()
{
int a[] = { 1,2,3,4 };
printf("%zd\n", sizeof(a));//这里 a 代表数组16
printf("%zd\n", sizeof(a + 0));// a+0 是一个指针,指向数组首元素8
printf("%zd\n", sizeof(*a));//解引用 a 得到数组首元素4
printf("%zd\n", sizeof(a + 1)); // a+0 是一个指针,指向数组第二个元素8
printf("%zd\n", sizeof(a[1]));  //数组的第二个元素4
printf("%zd\n", sizeof(&a));//数组的地址，也是一个指针8
printf("%zd\n", sizeof(*&a));   //数组的地址解引用，得到数组16
printf("%zd\n", sizeof(&a + 1));//跳过整个数组，但还是一个指针8
printf("%zd\n", sizeof(&a[0])); //取出第一个元素的地址，是一个指针8
printf("%zd\n", sizeof(&a[0] + 1));//第二个元素的地址，指针8
return 0;
}

5.2 字符数组

代码一：

#include<stdio.h>
int main()
{
char arr[] = { 'a','b','c','d','e','f' };//注意后面没有 \0
printf("%zd\n", sizeof(arr));//数组大小6
printf("%zd\n", sizeof(arr + 0));//指向第一个元素的指针8
printf("%zd\n", sizeof(*arr));//第一个元素的大小1
printf("%zd\n", sizeof(arr[1]));//第一个元素的大小1
printf("%zd\n", sizeof(&arr));//指向整个数组的指针8
printf("%zd\n", sizeof(&arr + 1));//跳过整个数组，但还是指针8
printf("%zd\n", sizeof(&arr[0] + 1));//指向第二个元素的指针8
return 0;
}

代码二：

#include<stdio.h>
int main()
{
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(arr));//从 arr 向后找 \0，字符串中没有随机值
printf("%d\n", strlen(arr + 0));//从 arr 向后找 \0，字符串中没有随机值
printf("%d\n", strlen(*arr));//传递给 strlen 一个字符报错
printf("%d\n", strlen(arr[1]));//传递给 strlen 一个字符报错
printf("%d\n", strlen(&arr));//从 arr 向后找 \0，字符串中没有随机值
printf("%d\n", strlen(&arr + 1));//跳过整个数组后开始找 \0随机值
printf("%d\n", strlen(&arr[0] + 1));//从第二个元素开始找 \0随机值
return 0;
}

未完待续……
由于最终篇内容较多，所以拆分成两篇。
谢谢你的阅读，喜欢的话来个点赞收藏评论关注吧！

原文地址：https://blog.csdn.net/fhvyxyci/article/details/140580379

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：如何让Python爬虫在遇到异常时继续运行
下一篇：【人工智能】Python实现文本转换为语音：使用gTTS库实现

SYN Flood攻击原理，SYN Cookie算法
SYN Flood攻击是一种典型的拒绝服务(Denial of Service)攻击。所谓的拒绝服务攻击就是通过进行攻击，使受害主机或网络不能提供良好的服务，从而间接达到攻击的目的。SYN Flood
阅读更多2024-09-22
vue入门小练习
vue入门小练习
阅读更多2024-09-22
嵌入式开发技巧和经验分享
今天有幸参加了一个嵌入式开发技巧和经验分享。我这里分享给大家，希望对喜欢和热爱嵌入式开发小伙伴有帮助深入探讨了嵌入式开发的关键概念和实践经验。首先，定义嵌入式系统及其操作系统，概述了开发环
阅读更多2024-09-22
智慧火灾应急救援航拍检测数据集（无人机视角）
智慧火灾应急救援。无人机，直升机等航拍视角下火灾应急救援检测数据集，数据分别标注了火，人，车辆这三个要素内容，29810张高清航拍影像，共31GB，适合森林防火，应急救援等方向的学术研究，落地应用
阅读更多2024-09-22
Hive parquet表通过csv文件导入数据
已建好了 hive parquet 格式的表, 需要从服务器的csv导入数据至该hive表。提前上传csv至服务器 /path/temp.csv。创建 textfile 格式的中转表 ,源表名。,这里
阅读更多2024-09-22
Android Studio 开发百度地图开发教程
本文讲解在Android Studio中使用百度地图进行开发项目。
阅读更多2024-09-22
claude，gpt，通义千问
起因是通义千问对这张图的解释有严重错误，因此想着让claude和gpt回答一下，记录一下。
阅读更多2024-09-22
【文献阅读】基于原型的自适应方法增强未见到的构音障碍者的语音识别
对于受影响的人来说，由于其有限的运动能力，语音是与设备互动的最方便手段。然而，传统的语音识别系统难以处理构音障碍者的语音，因为其显著偏离了典型的语音模式。HuBERT（Hidden-Unit BERT
阅读更多2024-09-22
【C++】模版进阶
对于模版的进一步认识
阅读更多2024-09-22
2024华为杯数模CDEF成品文章！【配套完整解题代码+数据处理】
实验表明，集成模型有效融合了各模型的优势。针对问题三，首先对题目中提到的自变量进行量化，建立逻辑回归模型，再利用移动平均线模型和LSTM神经网络进行预测，将预测的数据代入前面建立的逻辑回归模型进行降水
阅读更多2024-09-22