7.指针-进阶

已于 2024-03-25 19:42:24 修改
阅读量647 收藏 23
点赞数 7
分类专栏： c语言 文章标签： c语言
于 2024-03-25 19:39:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Q2691463021/article/details/137023466
版权

前言

  1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

  2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。

  3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。

  4. 指针的运算。

1. 字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ;

一般使用:

int main()
{
    char ch = 'w';
    printf("%c\n", ch);
    char *pc = &ch;
    *pc = 'e';
    printf("%c\n", ch);
   
    return 0;
}

int main()
{

	const char* p = "abcdef";//把字符串首字符a的地址，赋值给了p
	//char arr[] = "abcdef";
	//*p = 'w';     因为字符串"abcdef"是常量字符串 不能解引用之后被修改，因此用const来修饰 *p

	printf("%s\n", p);
	return 0;
}

思考打印的结果是什么
int main()
{
    // 把字符串首字符a的地址，赋值给了p
    // 常量字符串是不会被修改的，因此首元素的地址也是相同的
	const char* p1 = "abcdef";
	const char* p2 = "abcdef";

    // 将"abcdef"用来初始化数组，其实就是将常量区的字符串拷贝了一份，再进行数组的初始化
    // 因此两个数组首元素的地址是不一样的，因为它们是常量字符串的两份拷贝
	char arr1[] = "abcdef";
	char arr2[] = "abcdef";

	if (p1 == p2)
		printf("p1==p2\n");
	else
		printf("p1!=p2\n");

	if (arr1 == arr2)
		printf("arr1 == arr2\n");
	else
		printf("arr1 != arr2\n");

	return 0;
}

image-20220731221050032

2. 指针数组(存放指针的数组)

int* arr1[10];   //整型指针的数组
char* arr2[4];   //一级字符指针的数组
char** arr3[5];  //二级字符指针的数组
  • 下面的代码可以很好的帮助我们理解指针数组
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int* parr[3] = { arr1, arr2, arr3 };

	
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			//*(p+i) --> p[i]
			//printf("%d ", *(parr[i] + j));  两种打印方法都可以，是等价的
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}
  • 结合下面的图来分析上述代码

image-20220731222051275

3. 数组指针（指向数组的指针）

3.1 数组指针的定义

数组指针 ： 指向数组的指针

下面代码哪个是数组指针？

int* p1[10];
int (*p2)[10];    //p2的类型为 int(*)[10]


int *p1[10];
// 因为[]的优先级高于*，因此p1会先与[]结合，所以 p1[10]是一个数组，数组元素的类型为int*，因此为指针数组

int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组，数组每个元素为int类型。所以p是一个指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

3.2 &数组名VS数组名

数组名通常表示的都是数组首元素的地址
但是有2个例外：
1. sizeof(数组名),这里的数组名表示整个数组，计算的是整个数组的大小,单位是字节。
2. &数组名，这里的数组名表示的依然是整个数组，所以&数组名取出的是整个数组的地址

int main()
{
    int arr[10] = {0};
	// 数组首元素的地址
	printf("%p\n", arr);
    // 数组首元素的地址
	printf("%p\n", &arr[0]);
    // 整个数组的地址
	printf("%p\n", &arr);
	
	return 0;
}

image-20220731225021997

  • 下面这个代码可以区分arr和&arr的用法

int main()
{
    int arr[10] = {0};

	printf("%p\n", arr);
	printf("%p\n", arr+1);

	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0]+1);

	printf("%p\n", &arr);
	printf("%p\n", &arr+1);        //整个数组的地址+1，是跳过整个数组

	return 0;
}

image-20220731225200113

int main()
{              
	int arr[10] = {0};
    // 数组指针，这个指针指向一个数组
	int (*p)[10] = &arr;  
    return 0;             
}                         

// p（指针变量）的类型为int（*）[10]; p里面存放的是整个数组的地址； p+1 指针是跳过整个数组；
//  其实*p也相当于数组名，也就是数组首元素的地址
    

int main()
{
    char* arr[5] = {0};
	char* (*pc)[5] = &arr;
    
    
    char ch = 'w';
	char* p1 = &ch;
	char** p2 = &p1;
    
    return 0;
}

3.3 数组指针的使用

  • 先介绍一种不常用的数组指针的使用

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

	int (*p)[10] = &arr;
	
	int i = 0;
    // sz是数组元素的个数
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
        // p是指向数组的，*p其实就相当于数组名,数组名又是数组首元素的地址
        // 所以*p本质上是数组首元素的地址
		printf("%d ", *(*p+i));		                       
	}

	return 0;
}
  • 上面的代码使用起来非常的别扭，不如直接使用下面的代码来打印
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

    // p就是指针变量，存储的是数组首元素的地址
	int* p = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
    
    return 0;
}
  • 那么数组指针应该怎样来使用呢？请阅读以下代码
// int* p
// int arr[3][5],其实是一个二维数组的指针（接收的是二维数组首行的地址）
void print1(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
            // arr[0] -> *(arr+0)   两者是等价的； arr[0]就是二维数组的首行地址
            // arr+0是一个指针变量，它指向二维数组的首行地址， *(arr+0) 拿到首行元素的地址
            // arr[i][j] -> *(*(arr+i)+j)
			printf("%d ", arr[i][j]); 
		}
		printf("\n");
	}
}

// int (*p)[5] 接收的是第一行元素的地址
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]);            // p[i]就是第i行元素的首元素地址
		}
		printf("\n");
	}
}


int main()
{
    // arr是一个二维数组
	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
	print2(arr, 3, 5);
	
	return 0;
}
  • 对上述传参，和打印参数的分析如下

image-20220801140640668

image-20220801140846464

  • 学习了指针数组和数组指针，我们分析一下下面代码的意思
int arr[5];        		// 整形数组arr
int *parr1[10]; 		// 整型的指针数组parr1

int (*parr2)[10];		// 数组指针parr2
// *说明parr2是一个指针；   去掉parr2，可以看出类型为：int (*)[10]，说明parr2是一个指向数组的指针，且这个数组存放的元素类型为int

// 如下图所示
int (*parr3[10])[5];  // 存放数组指针的数组（int (*)[5] 是数组指针，parr3[10]是数组）
// 首先[]的优先级比*要高，因此parr3先于[10]结合，说明parr3[10]这是一个整体，是一个数组；parr3[10]前面有*，说明parr3[10]是一个指针数组
// 去掉parr3[10]，可以看到int (*)[5]，所以这个指针数组parr3[10]，存放的指针指向的是一个数组，这个数组存放的元素类型为int

image-20240324210017778

4. 数组参数、指针参数

4.1 一维数组传参

#include <stdio.h>
void test(int arr[])
{}

void test(int arr[10])
{}

void test(int *arr)
{}

// int arr[10] 传参对应 int arr[]
// int* arr2[20] 传参对应 int* arr2[20]
void test2(int* arr[20])
{}

void test2(int **arr)
{}

int main()
{
    // 对于int arr[10]，数组首元素的地址类型为int*
 	int arr[10] = {0};      //数组可以进行如上传参
    
    // 对于int* arr2[20]，数组首元素的地址类型为int**
 	int* arr2[20] = {0};    //指针数组可以进行如上传参
    
	test(arr);
 	test2(arr2);
    
    return 0;   
}

4.2 二维数组传参

void test(int arr[3][5])   //正确传参
{}
void test(int arr[][])     //错误传参
{}
void test(int arr[][5])    //正确传参(二维数组，行可以省略，但是列不可以)
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。



// 二维数组的数组名，表示的是首行的地址，也就是第一行元素的地址
// 第一行是一个有五个整型元素的一维数组，因此传参应该用数组指针来接收
// 第一行的类型为 int [5]
void test(int *arr)        //错误传参
{}
void test(int* arr[5])     //错误传参
{}

// arr指向一个数组，这个数组有5个元素，元素类型为int
// arr就是二维数组的首行地址
// *(arr+0) 就是首行首元素的地址；   *(*(arr+0)+0) 就是首行首元素
void test(int (*arr)[5])   //正确传参
{
    printf("%p\t", arr);
	printf("%p\t", *arr);
	printf("%p\t", **arr);
}
void test(int **arr)       //错误传参
{}

int main()
{
 	int arr[3][5] = {{1,2,3},{2,3,4},{4,5,6}};
	 test(arr);
}

4.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 arr[10] = {1,2,3,4,5,6,7,8,9};
 	int *p = arr;
 	int sz = sizeof(arr)/sizeof(arr[0]);
    
 	//一级指针p，传给函数
 	print(p, sz);
 	return 0; 
}

/*
思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
比如：
test1函数能接收什么参数？
*/

void test1(int *p)
{}

// 经过思考得
int main()
{
    int arr[] = {1,2,3,4,5};
    test1(arr);
    
    int a = 10;
    int* ptr = &a;
    test(&a);
    test1(ptr);
    
}

4.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);
     
    //指针数组也传参，也可以用二级指针接收，
    // 指针数组的每个元素都为char*， arr又为首元素的地址,所以数组首元素地址的类型就是char**,因此可以用二级指针来接收
	test(arr);   
   
	return 0; 
}

5. 函数指针(指向函数的指针)

  • 对比数组和函数
int Add(int x, int y)
{
	return x + y;
}

int main()
{
	//  数组
    int a = 10;
	int* pa = &a;
	*pa = 20;
	printf("%d\n", *pa);

    int arr[5] = {0};
    //&数组名 就是 取出整个数组的地址
    
    int (*p)[5] = &arr;//数组指针，这个指针p指向一个数组

    
    //  函数
    //&函数名 就是 取出的就是函数的地址呢？
    printf("%p\n", &Add);
    printf("%p\n", Add);
    //对于函数来说，(&函数名)和(函数名)都是函数的地址（可以自己在编译器上运行）
   
    // int (*pf)(int, int) = &Add;
    // pf就是一个函数指针，指向一个函数，这个函数的范围值为int，两个参数的类型是(int, int)
    int (*pf)(int, int) = Add;
    // 取函数的地址，放入函数指针，

    // *pf就是拿到函数
    int ret = (*pf)(2, 3);
    int ret = Add(2, 3);
    int ret = pf(2, 3);
  	//  *pf和pf都可以来调用Add函数;调用时(有无* 都可以);
  	// pf存放函数的地址，Add也就是函数的地址
  	// 因此Add(2, 3)就相当于pf(2, 3)
    
    printf("%d\n", ret);
    return 0;
}
  • 阅读两段有趣的代码：
//代码1 
( *(void (*)() )0 )();

注：void (*p)(); 其中p为函数指针， void (*)()为函数指针类型，这个函数指针指向的函数没有参数，返回值为void
    0 看做是整型  类型为int
    0 也可以看做是地址 0x00 00 00 00
因此，我们可以得出以下结论：
    以上代码是一次函数的调用，调用的是函数地址为0的函数。
    1.(void (*)())0； 就是将0强转为一个函数指针（指向的这个函数无参数，返回类型为void）；
    2.将(void (*)())0简化为函数指针p，那么 ( *(void (*)() )0 )() 就是(*p)()
    // 综上，( *(void (*)() )0 )() 就是调用函数地址为0的函数指针
    

//代码2
    void (* signal(int,void (*)(int)) )(int);
注： signal是函数名；	
    // 函数为signal(int , void (*)(int);   返回值为void (*)(int)
    因此我们可以得出结论：以上代码是一次函数声明
    1.声明的signal函数的第一个参数的类型是int，第二个参数的类型是函数指针void (*)(int)，
    且该函数指针指向的函数参数的类型为int，函数返回类型是void；
    2.signal函数的返回类型是void (*)(int)；
     
注：这个函数声明太复杂了，我们可以使用typedef将其简化如下
   typedef  void(* pf_t)(int) ; / /把void(*)(int)类型重命名为 pf_t
  则原代码就相当于 pf_t signal(int, pf_t)

函数指针的用途

简单的写一个满足加法、减法、乘法、除法的计算器

void menu()
{
	printf("*****************************\n");
	printf("****   1. add   2. sub  *****\n");
	printf("****   3. mul   4. div  *****\n");
	printf("****   0. exit          *****\n");
	printf("*****************************\n");
}

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}

//计算
//回调函数


// 使用函数指针pf来调用，相对应的函数
void calc(int (*pf)(int , int))
{
	int x = 0;
	int y = 0;
	int ret = 0;

	printf("请输入2个操作数:>");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}

int main()
{
	int input = 0;

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		
		switch (input)
		{
		case 1:
			calc(Add);
			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;
}
  • 思考 上述代码使用了函数指针 ，带来了那些便利？

由下图，我们可以得出结论，如果不使用函数指针，调用每一个函数的代码，都会有大量重复的代码。

image-20220815204218144

进阶第二部分

6. 函数指针数组

数组是一个存放相同类型数据的存储空间，比如：

int* arr[10];
//数组的每个元素是int*

6.1 函数指针数组的定义

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

函数指针数组：存放函数指针的数组

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}


int main()
{
	int (*pf)(int, int) = Add;  //pf是函数指针
    //arr就是函数指针的数组
	int (*arr[4])(int, int) = { Add, Sub, Mul, Div };
    //arr[4]数组中每个元素的类型为 int (*)(int,int)
    
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = arr[i](8, 4);  //调用函数指针数组中的函数
		printf("%d \n", ret);
	}

	return 0;
}
  • 附图一张，便于大家理解函数指针数组

image-20220815212950354

6.2 函数指针数组的应用

void menu()
{
	printf("*****************************\n");
	printf("****   1. add   2. sub  *****\n");
	printf("****   3. mul   4. div  *****\n");
	printf("****   0. exit          *****\n");
	printf("*****************************\n");
}

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	//函数指针的数组
	//转移表
	int (*pfArr[])(int, int) = {0, Add, Sub, Mul,  Div};

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);//pfArr[1]:即调用函数指针数组中下标为1的函数
			printf("%d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}

	} while (input);

	return 0;
}

7. 指向函数指针数组的指针

int main()
{
	//函数指针数组
	int (*pfArr[])(int, int) = { 0, Add, Sub, Mul,  Div };

	//指向【函数指针数组】的指针
    // (*ppfArr) 说明ppfArr是一个指针，指向函数指针数组int (* [5])(int, int)
	int (*(*ppfArr)[5])(int, int) = &pfArr;

	return 0;
}

8. 回调函数

1.回调函数就是一个通过函数指针调用的函数。
2.如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
3.回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

8.1 冒泡排序

9 8 7 6 5 4 3 2 1
第一趟之后就是： 8 7 6 5 4 3 2 1 9   // 第一趟进行8次比较，第二趟进行7次比较
第二趟之后就是： 7 6 5 4 3 2 1 8 9
// 9个数一共需要9趟

void bubble_sort(int arr[], int sz)
{
	int i = 0;
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		//假设数组已经按照从小到大排好序了，这时flag为1
		int flag = 1;
		//一趟冒泡排序的过程
		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;

				// 说明此时还没有排序完成
				flag = 0;
			}
		}

		if (flag == 1)
		{
			break;
		}
	}
}

int main()
{
	int arr[] = { 10,2,3,4,5,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);

	int i = 0;
	while (sz)
	{
		printf("%d\t", *(arr + i));
		i++;
		sz--;
	}
	return 0;
}

8.2 qsort 函数

  • 再使用qsort函数之前 我们需要了解如下的知识点
// c语言库中的快速排序接口
//  void qsort(void* base,//你要排序的数据的起始位置
//  	       size_t num,//待排序的数据元素的个数
//  	       size_t width,//待排序的数据元素的大小（单位是字节）
//  	       int(* cmp)(const void* e1, const void* e2)//函数指针-比较函数
//           );


int main()
{
	int a = 10;
	//char* pa = &a;// int*和char*类型不同
	void* pv = &a;//void*是无具体类型的指针，可以接受任意类型的地址
	//void*是无具体类型的指针，所以不能解引用操作，也不能+-整数

	return 0;
}

image-20220815221337075

image-20220815221309475

image-20220815221438620

  • 利用qsort来排序
//qsort -这个函数可以排序任意类型的数据

//  void qsort(void* base,//你要排序的数据的起始位置
//  	       size_t num,//待排序的数据元素的个数
//  	       size_t width,//待排序的数据元素的大小（单位是字节）
//  	       int(* cmp)(const void* e1, const void* e2)//函数指针-比较函数
//           );

#include <stdlib.h>

//比较2个整型元素
//e1指向一个整数
//e2指向另外一个整数

// 第一种cmp_int 函数
int cmp_int(const void* e1, const void* e2)
{
    // 根据compare函数的返回值制定的规则
	if (*(int*)e1 < *(int*)e2)                //因为void* 不能够被解引用，
        return -1;                            //又因为已知比较数据的类型为int，所以强转为int*
    else if (*(int*)e1 > *(int*)e2)
        return 1;
    else
        return 0;
}

// 第二种cmp_int 函数（简洁并且和第一种的效果相同）
int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}

void test1()
{
	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
	//0 1 2 3 4 5 6 7 8 9
	//把数组排成升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	//bubble_sort(arr, sz);

	qsort(arr, sz, sizeof(arr[0]), cmp_int);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

8.2.1我们也可以利用qsort函数来对结构体排序

首先我们需要了解一个比较字符串的函数strcmp。

image-20220817143722493

image-20220817144156136

// 这是一个学生的结构体
struct Stu
{
	char name[20];
	int age;
};


// 1.可以通过每个学生的姓名来排序
// strcmp
// abbdef
// abbqwerttt    （a的ASCILL值小于b，所以b比a大）
// 这两个字符串通过strcmp比较，首先是对两个字符串的首元素进行比较，其次第二个元素，以此类推；

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


// 2.也可以通过年龄来排序
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}


void test2()
{
	//测试使用qsort来排序结构数据
	struct Stu s[] = { {"zhangsan", 15}, {"lisi", 30}, {"wangwu", 25} };
	int sz = sizeof(s) / sizeof(s[0]);
	
    //qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}



int main() 
{
  //test1()；
  //test2();
    return 0;
}

8.2.2 模仿qsort来改造我们自己写的bubble_sort


//  void qsort(void* base,//你要排序的数据的起始位置
//  	       size_t num,//待排序的数据元素的个数
//  	       size_t width,//待排序的数据元素的大小（单位是字节）
//  	       int(* cmp)(const void* e1, const void* e2)//函数指针-比较函数
//           );

// 由qsort 得
// void bubble_sort(void*base,  //你要排序的数据的起始位置
//                  int sz,     //待排序的数据元素的个数
//                  int width,  //待排序的数据元素的大小（单位是字节）
//                  int(*cmp)(const void*e1, const void*e2) /函数指针-比较函数
//                  );

 //1. 当对数字进行比较时，调用 cmp_int
int cmp_int(const void* e1, const void* e2)
{
  return (*(int*)e1 - *(int*)e2);
}


 //2.当对字符串进行比较时，调用cmp_stu_by_name
int cmp_stu_by_name(const void* e1, const void* e2)
{
	//strcmp --> (>0   ==0   <0)
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}


// 交换函数
void Swap(char* buf1, char* buf2, int width)  
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

//  width: 传参对象的大小，单位为byte
//  由于并不知道使用者会传参什么类型的对象的地址，
// （注char* arr+1，每次跳过1byte； int* arr+1，每次跳过4byte）
// 1.因此(char*)base+j*width, (char*)base+(j+1)*width)分别是我们将比较或者将交换的两个对象的地址
// 2.char*类型，每次解引用只能解引用一个字节，因此对于任何类型的对象，我们都可以一个字节一个字节的交换。
//   所以我们需要将传递的对象的地址强制转化为char*类型


void bubble_sort(void* base, int sz, int width, int(*cmp)(const void* e1, const void*e2))
{
	int i = 0;
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设数组是排好序
		//一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
            // cmp() 返回值如果大于0，说明e1 > e2
			if (cmp((char*)base+j*width, (char*)base+(j+1)*width)>0)
			{
				// 使用交换函数，交换两个元素的位置
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}


// 对数组进行排序
void test3()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//0 1 2 3 4 5 6 7 8 9
	//把数组排成升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	//bubble_sort(arr, sz);

	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}


// 对结构体进行排序
void test4()
{
	//测试使用qsort来排序结构数据
	struct Stu s[] = { {"zhangsan", 15}, {"lisi", 30}, {"wangwu", 25} };
	int sz = sizeof(s) / sizeof(s[0]);
	
    bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	//bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}


int main()
{
    test3();
    test4();
        
    return 0;
}
the_nov
关注
  • 7
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C语言-进阶】指针进阶
TPON的博客
03-04 6376
c进阶 - 指针进阶
C语言实现扫雷-进阶.zip
12-04
7. **函数设计与调用**：项目中包含`game.c`、`infor.c`和`test.c`三个源文件，这些文件可能包含了不同的功能模块，如游戏逻辑、用户交互和测试代码。理解和编写函数接口对于项目协作至关重要。 8. **头文件...
C语言指针-- 进阶学习（二）
梅山
09-01 913
指针进阶（一） 指针的运算 1、指针的运算 指针+整数 = 指针 指针-整数 = 指针 和加法的规则一样。 结论：实际增加\减少 = 整数 +- 指针所指向类型所占内存大小 int a = 10,b = 20,c = 30; printf("a=%d,b=%d,c=%d\n",a,b,c); int *pa = &a,*pb = &b,*pc = &c; printf("pa=%d,pb=%d,pc=%d\n",pa,pb,pc); int *pd = pa +
详解指针进阶-初学者也能看懂
C、Java知识分享
01-20 1968
c语言指针，一篇就够~
指针---进阶篇(二)
weixin_75128035的博客
08-10 1571
o.O这是尊嘟假嘟
C语言指针全归纳-进阶版
weixin_53451597的博客
04-04 3733
大家好，上次的初阶版让我第一次尝到了写博客的甜头，原来可以有这么多人看我的博客呀，非常感谢大家对我的支持与鼓励，我一定会再接再厉，继续创作出优质的内容来向大家分享知识。 进阶的内容比较庞大，所以我会分为多篇博客进行上传，请大家敬请期待，当然如果我有错误的地方希望大家可以指正我的错误，万分感谢 防止有些博友没有看过前一篇我的博客，在此简单概括一下那篇博客的内容有哪些。 指针变量是用来存放地址的，对其解引用就可以找到该地址唯一标识的内存空间 指针大小在32位平台上为4字节，在64位平台上为8字节 指针具有类型
11.进阶-索引-结构-Btree
m0_63464979的博客
07-06 333
B-Tree，B树是一种多叉路衡查找树，相对于二叉树，B树每个节点可以有多个分支，即多叉。2、一旦节点存储的key数量到达5，就会裂变，中间元素向上分裂。1、5阶的B树，每一个节点最多存储4个key，对应5个指针。知识小贴士: 树的度数指的是一个节点的子节点个数。3、在B树中，非叶子节点和叶子节点都会存放数据。
C语言-函数指针-快速排序算法(蓝牙信号强度-进阶)
qq_36075612的博客
10-19 879
C语言-函数指针-快速排序算法(蓝牙信号强度-进阶)
MyBatis-Plus进阶之常用配置，看完别说不懂MyBatis-Plus配置
热门推荐
qq_36551991的博客
01-26 2万+
目录前言基础配置Configuration配置GlobalConfig配置dbConfig配置 前言 下面介绍下MyBatis-Plus在使用过程中的常用配置选项，其中，部分配置继承自MyBatis原生所支持的配置 下面是在两种不同配置文件配置的示例： yml文件： mybatis-plus: ...... configuration: ...... global-config: ...... db-config: ...... properties文件
C语言---指针进阶
binhyun的博客
02-16 801
字符指针，指针数组，数组指针，二维数组传参
C语言 --- 进阶指针（接上篇，已完结）
qq_61688804的博客
03-14 1155
嗨害嗨，我又来了，接着来更新我们的进阶指针的内容，这篇文章是接着上篇的内容的，因为考虑到篇幅过长看着太累，所以就把这后面的内容分了出来，如果大家想看完整的主页就有，欢迎大家来一起交流！ 好了，废话我说完了，我们开始正片.......... 7，指向函数指针数组的指针 7.1，定义及其基本使用 定义：首先是一个指针，这个指针指向的是函数指针数组。 使用： ...
C++基础-进阶.rar
11-06
7. **命名空间**：理解命名空间的作用，避免全局作用域的命名冲突。 8. **预处理器宏**：虽然不是推荐的编程实践，但了解宏定义和预处理器指令可以帮助理解一些旧代码。 最后，通过项目历练，学习者可以将理论知识...
大学计算机C语言课程-第十一章-指针进阶.ppt
05-24
【指针进阶】在C语言中，指针是编程中的关键概念，它允许我们直接操作内存地址。在第十一章“指针进阶”中，我们深入探讨了指针的高级用法。 1. **指针数组**：在11.1节“布袋中的彩色球”中，通过一个例子展示了...
C/C++控制台贪吃蛇游戏的实现
fzy20110826的博客
08-20 3119
本文对给定的贪吃蛇游戏代码进行详细分析。该游戏使用 C++语言编写，通过控制台界面实现了经典的贪吃蛇游戏玩法，包括登录、注册、游戏介绍、游戏操作和计分等功能。
c/c++基础及类和对象汇总
2301_77479435的博客
08-27 1246
c/c++基础及类和对象汇总
20240824给飞凌OK3588-C的核心板刷Ubuntu22.04并连接adb
南岭笑笑生之家
08-24 1102
缘起，由于我司对面积有极度的追求，所以将飞凌OK3588-C开发板使用的【9线+】type-C接口（USB3.1?）降级为4线的USB2.0。当然你有能力的话，貌似可以把需要安装的软件直接打包到Ubuntu22.04的文件系统中。2、通过USB数据线链接到你的电脑。如果连接不上，多插拔几次USB数据线，重启 飞凌OK3588-C的核心板 也是可选项！3、给飞凌OK3588-C的核心板 安装 ADB。
C语言 | Leetcode C语言题解之第377题组合总和IV
m0_59237910的博客
08-27 656
C语言 | Leetcode C语言题解之第377题组合总和IV
【Java 设计模式-源码】Caching 模式：加速数据访问速度
最新发布
08-28
一、概述 在 Java 开发中，Caching 模式是一种重要的性能优化和资源管理模式。它涉及各种缓存策略，如写通、读通和 LRU 缓存，以确保高效的数据访问。Caching 模式通过避免在使用后立即释放资源，而是将其保留在快速访问存储中，从而避免了昂贵的资源重新获取。 二、Caching 设计模式的别名 Cache Temporary Storage 三、Caching 设计模式的意图 Java 中的 Caching 设计模式对于性能优化和资源管理至关重要。它涉及各种缓存策略，如写通、读通和 LRU 缓存，以确保高效的数据访问。Caching 模式避免了在使用后立即释放资源，而是将其保留在一些快速访问存储中，并重新使用它们，以避免再次获取它们的开销。 四、Caching 模式的详细解释及实际示例 实际示例： Java 中 Caching 设计模式的一个现实世界示例是图书馆的目录系统。通过缓存频繁搜索的图书结果，系统减少了数据库负载并提高了性能。当读者频繁搜索热门图书时，系统可以缓存这些搜索的结果。而不是每次用户搜索热门图书时都查询数据库，系统可以快速从缓存中检索结果。这减少了数据库的
指针进阶：链表实现与操作
"该资源是关于指针进阶的教程，特别关注了链表的概念和结点定义。在第11章中，讲解了指针的高级应用，包括指针数组、指向指针的指针、函数返回值的指针、指向函数的指针以及结构的递归定义。此外，还通过学生信息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值