C语言--指针进阶（补充）

已于 2023-10-18 18:14:27 修改
阅读量81 收藏 1
点赞数 2
文章标签： 数据结构
于 2023-09-16 17:03:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liu_20236666/article/details/132917503
版权

目录

一.函数指针--实现回调函数

1.要点明晰

2.进阶使用

(1)实现过程(整形数据)

①函数初步构造

② 函数完整构造

​③完整代码展示  

 (2)实现过程(结构体数据)

①函数构造 

函数指针--实现回调函数

1.要点明晰

 普通的冒泡排序算法能排序的数据类型是确定的，因此在排序其他类型的数据的时，算法需要修改的地方较多，因此我们希望创建出来了一个可以排序任意数据类型的冒泡排序算法。

  •  普通冒泡排序
void bubble(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz-1; i++)//确定趟数
	{
		int j = 0;
		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;
			}
		}
}
这里如果想要排序结构体类型的数据，函数参数的类型是不匹配的

2.进阶使用

使用【冒泡排序】的算法，模拟实现一个排序函数，可以排序任意类型的数据 

(1)实现过程(整形数据)

 ①函数初步构造
//int (*cmp)(const void* e1, const void* e2)
//e1是一个指针，存放了一个要比较的元素的地址
//e2是一个指针，存放了一个要比较的元素的地址
//e1指向的元素>e2指向的元素，返回>0的数字
//e1指向的元素==e2指向的元素，返回0
//e1指向的元素<e2指向的元素，返回<0的数字

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
void bubble_sort(void*base, size_t num, size_t size, int (*cmp)(const void *e1,const void *e2))
//                            元素个数   每个元素的大小
{
	int i = 0;
	for (i = 0; i < num-1; i++)//确定趟数
	{
		int j = 0;
		for (j = 0; j < num - 1 - i;j++)//确定元素比较的次数
		{
			//if (arr[j] > arr[j + 1])
			if(cmp(         )>0) 这里要清楚arr[j]和arr[j+1]的地址
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
void test()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
}
  • 找到每个元素的地址

② 函数完整构造
//int (*cmp)(const void* e1, const void* e2)
//e1是一个指针，存放了一个要比较的元素的地址
//e2是一个指针，存放了一个要比较的元素的地址
//e1指向的元素>e2指向的元素，返回>0的数字
//e1指向的元素==e2指向的元素，返回0
//e1指向的元素<e2指向的元素，返回<0的数字
int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
 void swap(char* buf1, char* buf2, size_t size)
{
	 int i = 0;
	 for (i = 0; i < size; i++)
	 {
		 char tmp = *buf1;
		 *buf1++ = *buf2;
		 *buf2++ = tmp;
	 }
}
void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void* e2))
//                            元素个数   每个元素的大小
{
	int i = 0;
	for (i = 0; i < num - 1; i++)//确定趟数
	{
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)//确定元素比较的次数
		{
			//if (arr[j] > arr[j + 1])
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
  •  交换条件图示
 
③完整代码展示  
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
//int (*cmp)(const void* e1, const void* e2)
//e1是一个指针，存放了一个要比较的元素的地址
//e2是一个指针，存放了一个要比较的元素的地址
//e1指向的元素>e2指向的元素，返回>0的数字
//e1指向的元素==e2指向的元素，返回0
//e1指向的元素<e2指向的元素，返回<0的数字

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
 void swap(char* buf1, char* buf2, size_t size)
{
	 int i = 0;
	 for (i = 0; i < size; i++)
	 {
		 char tmp = *buf1;
		 *buf1++ = *buf2;
		 *buf2++ = tmp;
	 }
}
void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void* e2))
//                                             元素个数   每个元素的大小
{
	int i = 0;
	for (i = 0; i < num - 1; i++)//确定趟数
	{
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)//确定元素比较的次数
		{
			//if (arr[j] > arr[j + 1])
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
void test()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}

 (2)实现过程(结构体数据)

①函数构造 
struct Stu
{
	char name[20];//20
	int age;//4
};

int cmp_stu_by_age(const void* e1, const void*e2)//按照年龄比较
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}


int cmp_stu_by_name(const void* e1, const void* e2)//按照姓名比较
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void*e2))
{
	//冒泡排序的趟数
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1])
			if(cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

void test2()//比较name
{
	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15}};
	int sz = sizeof(arr) / sizeof(arr[0]);//3
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}

int main()
{
	//测试bubble_sort，排序结构体的数据
	test2();
	return 0;
}

 实现结果：

  •  流程展示

 ②完整代码展示
#include <stdio.h>
#include <stdlib.h>
struct Stu
{
	char name[20];//20
	int age;//4
};

int cmp_stu_by_age(const void* e1, const void*e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}


int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void*e2))
{
	//冒泡排序的趟数
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1])
			if(cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)
			{
				//交换
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

void test2()
{
	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15}};
	int sz = sizeof(arr) / sizeof(arr[0]);//3
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}

int main()
{
	//测试bubble_sort，排序结构体的数据
	test2();
	return 0;
}

 结果：

川辞.
关注
C语言进阶---指针的进阶
m0_57776598的博客
06-17 1193
本章详细讲解了C语言的指针进阶部分，主要内容有：字符指针，数组指针，指针数组、数组传参和指针传参、函数指针、函数指针数组、指向函数指针数组的指针。以及重点讲解了qsort()函数的使用，并且自己模拟实现qsort()功能，最后还有指针和数组的面试以及笔试题。干货满满，快来学习把！！！
C语言----指针进阶（万字详解）
2301_77459845的博客
07-11 324
前段时间，学习了指针初阶的知识，这里再简单回顾下。指针是个变量，用来存放地址，地址唯一指向一块内存空间（地址==指针）指针的大小是固定的，4个字节（32位平台）或8个字节（64位平台），32位机器=32个地址线->0/1——32个0/1组成的二进制序列=32个地址，需要32个bit位即4个字节存储起来，64位同理指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限指针的运算数组指针是什么，我们可以类比一下。
C语言-指针进阶
weixin_72501602的博客
03-04 580
指针进阶学习，对于初学指针的同学可能有一定难度
C语言-指针进阶详解
qq_74732628的博客
07-07 531
指针进阶的知识
C语言头歌:指针进阶
weixin_65370416的博客
02-26 892
个学生的成绩，成绩都为整数，用指针函数求出若干个学生成绩的最高分。####相关知识（略） ####编程要求 请仔细阅读右侧代码，结合相关知识，在。个位置 ####相关知识（略） ####编程要求 请仔细阅读右侧代码，结合相关知识，在。题目描述:采用指针变量表示地址的方法输入输出数组中的个元素。输出最高分，占一行。用指针变量表示地址的方法输出数组中的各个元素。请仔细阅读右侧代码，结合相关知识，在。开始你的任务吧，祝你成功！开始你的任务吧，祝你成功！开始你的任务吧，祝你成功！区域内进行代码补充。
C语言 --- 进阶指针（未完待续.....）
qq_61688804的博客
03-05 1007
目录 一，初级指针回顾 二，进阶指针 1，字符指针 1.1，基本定义与用法 1.2，使用细节 2，指针数组 2.1，基本定义及其使用 3，数组指针 3.1，基本定义 3.2，&数组名与数组名 3.3，数组指针的使用 一，初级指针回顾 1，首先，我们得认识到，指针的本质还是一个变量，只不过这个变量存放的是地址。在我们的计算机中，内存会划分为很多小的存储单元，而每一个存储单元都会有自己独有的内存编号，这个内存编号就是这块内存单元的地址。所以，内存编号 = 指针 =
笔记19-1（C语言进阶 指针进阶）
w_pab的博客
04-16 1129
指针就是给变量，用来存放地址，地址唯一标识一块内存空间。 指针的大小是固定的4/8个字节（32位平台/64位平台）。 指针是有类型的，指针的类型决定了：①指针的±整数的步长，②指针解引用操作时的权限。 字符指针 有一种指针的类型为字符指针 char* 一般使用： int main() { char ch = 'q'; char * pc = &ch; *pc = 'w'; return 0; } 但是，字符指针不仅可以指向字符，还可以指向字符串： int main().
C语言进阶-指针进阶（2）
syh163的博客
10-10 72
那类比一下，函数指针数组就是存放函数指针的数组。在学习函数指针数组之前，我们先来用前面学过的知识实现一个计算器（加法、减法、乘法、除法） ，以上代码分别写出加减乘除功能的函数，并将个函数的地址存放在函数指针中，我们可以发现，这几个函数的参数类型和返回类型是相同的，那我们能不能把它们放在一个数组中呢？当然可以，这个数组就被称为函数指针数组。通过观察其实可以发现，函数指针数组其实就是在，pf和[4]先结合成数组，数组中存放的数据类型是函数指针类型。
c语言--指针进阶（3）函数指针数组、指向指针数组的指针、回调函数
m0_61402375的博客
08-18 75
函数指针数组、指向指针数组的指针、回调函数
c语言指针的进阶
weixin_47270825的博客
10-16 695
函数指针 获得函数地址的方式可以是函数名和&函数 两个值的结果相同。 保存函数地址的变量称为函数指针变量
C语言无人超市管理系统进阶版本
m0_55728779的博客
06-24 4049
题目如下： 设计一个无人超市管理系统，要求至少实现如下功能： 1.用户注册系统 2.管理系统 3.进一步设计用户系统
C语言指针进阶，一维数组和二维数组
Chu_wenchen的博客
05-08 547
一维数组： void test(int arr[]) // 可行，arr是一个整型数组，创建一个整型数组接收 {} void test(int arr[10]) // 可行，与上一种形式没有什么区别，10可以省略 {} void test(int *arr) // 可行，实参arr，数组名本质上是首元素的地址，而元素是int类型，所以可以用整型指针接收 {} void test2(int *arr[20]) // 可行，实参brr，是一个存放了20个元素的数组，每个元素类
第四站:指针的进阶-(二级指针,函数指针)
qq_48397625的博客
01-08 1988
cout
C语言n番战--指针（五）
weixin_50546241的博客
05-04 1319
C语言n番战--指针（五）
【高阶数据结构】平衡二叉树(AVL)的删除和调整
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
09-26 979
平衡二叉树节点的删除方法详细讲解；平衡二叉树的删除代码实现(C++);
数据结构-3.8.栈在括号匹配中的应用
ADCvbV的博客
10-01 255
把左括号依次压入栈中，越往后压入栈的左括号越先被匹配即被弹出栈->先进后出，后进先出当遇到左括号就压入栈中，当遇到右括号就把栈顶的左括号弹出，检查该右括号和左括号是否匹配当遇到一个不匹配的就停止压入栈，因为之后的括号必定都不匹配。其中Y代表Yes，N代表No1.对于bracketCheck函数，形参str[]是传入的一个字符串，length是该字符串的长度；字符topElem代表栈顶元素；return StackEmpty(S)如果是return false说明栈不为空，则左括号单身；创建栈顶元素topEl
数据结构-3.10.队列的应用
最新发布
ADCvbV的博客
10-01 196
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1135
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
C语言与C++进阶精华：动态数组与类模板详解
这部分内容对于熟悉C语言后想要进一步学习C++的读者来说是非常有价值的补充。 4. **参数为指针的函数用法** - 指针在C和C++中扮演着核心角色，函数接收指针参数可以让开发者操作变量的地址，而非复制值。文章可能...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值