阀门专业网站建设,seo运营工作内容,专业制作网站系统,网络规划设计师第二版pdf百度云☃️内容专栏#xff1a;【C语言】进阶部分 ☃️本文概括#xff1a; 征服C语言指针#xff01;一篇文章搞清楚指针的全部要点。 ☃️本文作者#xff1a;花香碟自来_ ☃️发布时间#xff1a;2023.3.3 目录
一、字符指针
二、指针数组
三、数组指针
1.数组指针的定义… ☃️内容专栏【C语言】进阶部分 ☃️本文概括 征服C语言指针一篇文章搞清楚指针的全部要点。 ☃️本文作者花香碟自来_ ☃️发布时间2023.3.3 目录
一、字符指针
二、指针数组
三、数组指针
1.数组指针的定义
2.数组名和数组名
3.数组指针的使用
四. 数组传参和指针传参
1.一维数组传参
2.二维数组传参
3.一级指针传参
4.二级指针传参
五. 函数指针
1.函数指针
2.利用函数指针
3.阅读两段有趣的代码
六. 函数指针数组
1.函数指针的使用
2.函数指针数组的应用
七. 指向函数指针数组的指针
八. 回调函数
九、qsort函数的应用
1.利用qsort来排序整型数组
2 利用qsort来排序结构体数据
十、以冒泡排序的思想模拟实现qsort函数 一、字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char*
一般这么使用
int main()
{char ch w;char *pc ch;*pc w;return 0;
}
但是还有一种方式
字符串常量
int main()
{const char* pstr hello world.;//这里是把一个字符串放到pstr指针变量里了吗printf(%s\n, pstr);return 0;
} 以上特别容易以为是把字符串 hello world.放到字符指针 pstr 里了其实是把字符串的首字符地址h的地址存放到字符指针变量 pstr 当中如果当32位平台4个字节大小的指针变量pstr能够装得下字符串吗显然不能。 需要注意的一点观察以下图 好了小伙伴们理解了吗下面来看一道来自于《剑指offer》当中的一道题:
#includestdio.h
int main()
{char str1[] hello world.;char str2[] hello world.;const char *str3 hello world.;const char *str4 hello world.;if(str1 str2)printf(str1 and str2 are same\n); elseprintf(str1 and str2 are not same\n);if(str3 str4)printf(str3 and str4 are same\n);elseprintf(str3 and str4 are not same\n);return 0
} 这里str3和str4指向的是一个同一个常量字符串。C/C会把常量字符串存储到单独的一个内存区域当几个指针指向同一个字符串的时候他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同str3和str4不同。 二、指针数组 指针数组就是存放指针的数组int* arr1[10] 表示存放整型指针的数组char* arr2[20] 表示存放字符指针的数组。 应用:
int main()
{/* char* arr[] { abcdef, hehe, qwer };int i 0;for (i 0; i 3; i){printf(%s\n, arr[i]);} */int arr1[] { 1,2,3,4,5 };int arr2[] { 2,3,4,5,6 };int arr3[] { 3,4,5,6,7 };//arr[i] *(arri)//arr是一个存放整型指针的数组int* arr[] { arr1, arr2, arr3 };int i 0;for (i 0; i 3; i){int j 0;for (j 0; j 5; j){//printf(%d , arr[i][j]);printf(%d , *(arr[i]j));}printf(\n);}return 0;
}三、数组指针
1.数组指针的定义 整形指针 int * pint; 能够指向整形数据的指针。 浮点型指针 float * pf; 能够指向浮点型数据的指针。 那数组指针应该是能够指向数组的指针。 //下面代码哪个是数组指针?
int main()
{int *p1[10];int (*p2)[10];//p1, p2分别是什么return 0;
}解释int (*p)[10]; //解释p先和*结合说明p是一个指针变量然后指着指向的是一个大小为10个整型的数组。所以p是一个 指针指向一个数组叫数组指针。 //这里要注意[ ]的优先级要高于*号的所以必须加上来保证p先和*结合。 2.数组名和数组名 我们知道数组名绝大部分情况下是数组首元素的地址。 但是有两种特殊情况 1. sizeof(数组名) - sizeof内部单独放一个数组名的时候数组名表示的整个数组计算得到的是数组的总大小。 2. arr - 这里的数组名表示整个数组取出的是整个数组的地址从地址值的角度来讲和数组首元素的地址是一样的但是意义不一样。 观察以下代码
#includestdio.h
int main()
{int arr[10] { 0 };//printf(%d\n, sizeof(arr));printf(%p\n, arr);//其类型是int * printf(%p\n, arr1);//4printf(%p\n, arr[0]);//int* printf(%p\n, arr[0]1);//4printf(%p\n, arr);//其类型是int(*)[10]printf(%p\n, arr1);int (*p)[10] arr;//p是一个数组指针//int(*)[10] return 0;
} 解释根据上面的代码我们发现其实arr和arr虽然值是一样的但是意义应该不一样的。 实际上 arr 表示的是数组的地址而不是数组首元素的地址。细细体会一下 本例中 arr 和 arr[0] 表示的都是数组首元素的地址arr 1和arr[0] 1 需要看数组首元素地址的类型是int *所以加一跳过一个整型的大小。而arr 的类型是 int(*)[10] 是一种数组指针类型 数组的地址1跳过整个数组的大小所以 arr1 相对于 arr 的差值是40。 3.数组指针的使用 那数组指针是怎么使用的呢 既然数组指针指向的是数组那数组指针中存放的应该是数组的地址。 #includestdio.h
int main()
{int arr[10] { 1,2,3,4,5,6,7,8,9,10 };int sz sizeof(arr) / sizeof(arr[0]);int (* p)[10] arr;int i 0;//p --- arr//*p --- *arr//*p --- arrfor (i 0; i sz; i){printf(%d , *((*p) i));}//虽然对但是有点别扭不推荐 //一般还是将数组名存放到一个整型指针中再访问使用//int* p arr;//for (i 0; i sz; i)//{// printf(%d , *(p i));//}return 0;
} 一个数组指针的使用二维数组传参
#includestdio.h
void print(int(*arr)[5], int row, int col)
{int i 0;for (i 0; i 3; i){int j 0;for (j 0; j 5; j){//*(arr 0) arr[0] arr[0][0] 为第一行数组首元素的地址……以此类推printf(%d , *(*(arr i) j));//printf(%d , arr[i][j]);//和以上代码表示一样}printf(\n);}
}
int main()
{int arr[3][5] {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};//二维数组的数组名也表示首元素的地址//二维数组可以理解为起始是一维数组的数组//二维数组的首元素是第一行一维数组//首元素的地址就是第一行的地址,是一个一维数组的地址print(arr, 3, 5);return 0;
} 辨别一下以下代码
int arr[5]; //整型数组int *parr1[10]; //指针数组int (*parr2)[10]; //数组指针int (*parr3[10])[5]; //存放数组指针的数组 四. 数组传参和指针传参
在写代码的时候难免要把【数组】或者【指针】传给函数那函数的参数该如何设计呢
1.一维数组传参 对于函数test一维整型数组传参形参部分可以是数组的形式接收也可以是指针的形式接收。 对于函数test2指针数组传参形参部分可以是指针数组的形式接收也可以是二级指针的形式接收。 #include stdio.h
void test(int arr[])// ture
{}
void test(int arr[10])// ture
{}
void test(int* arr)// true
{}
void test2(int* arr[20])// true
{}
void test2(int** arr)// true
{}
int main()
{int arr[10] { 0 };int* arr2[20] { 0 };test(arr);test2(arr2);
}2.二维数组传参 如果是数组行可以省略但是列不能省略。如果是指针传过去的是第一行的地址形参部分接收的就应该是数组指针。 void test(int arr[3][5])//ture
{}
void test(int arr[][])//false
{}
//总结二维数组传参函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组可以不知道有多少行但是必须知道一行多少元素。
//这样才方便运算。
void test(int arr[][5])//ture
{}
void test(int *arr)//false
{}
void test(int* arr[5])//false
{}
void test(int (*arr)[5])//ture
{}
void test(int **arr)//false
{}
int main()
{int arr[3][5] {0};test(arr);
}
3.一级指针传参
#include stdio.h
void print(int *p, int sz)
{int i 0;for(i0; i sz; i){printf(%d\n, *(pi));}
}
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;
} 思考 当一个函数的参数部分为一级指针的时候函数能接收什么参数 void test1(int *p) {} //test1函数能接收什么参数 一级指针整型变量的地址整型的一维数组名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 test2(int **p) {} //test2函数能接收什么参数 二级指针变量一级指针变量的地址整型的指针数组的数组名五. 函数指针
1.函数指针
首先看一段代码
#include stdio.h
void test()
{printf(hehe\n);
}
int main()
{printf(%p\n, test);printf(%p\n, test);return 0;
} 输出的是两个地址这两个地址是 test 函数的地址。 那我们的函数的地址要想保存起来怎么保存 void (*pfun)(); 解释pfun就是一个函数指针。pfun先和*结合说明pfun是指针指针指向的是一个函数指向的函数无参数返回值类型为void。 ⚠️注意函数名和函数名是一样的都表示的是函数的地址。 2.利用函数指针
int Add(int x, int y)
{return x y;
}
#includestdio.h
int main()
{//函数指针变量int (*pfun)(int, int) Add;//调用函数int ret1 (*pfun)(3, 5); //函数的地址存放到函数指针当中printf(%d\n, ret1);//我们平常写的函数调用int ret2 Add(4, 7);printf(%d\n, ret2);//那么就有以下表示方法int ret3 pfun(8, 9);//所以我们知道 pfun和*pfun是一样的这里的*只是帮助理解加多少个*都只是摆设printf(%d\n, ret3);return 0;
} 那么假设一个函数是这么写的 char* test(int cfloat* pf),那么这个函数指针该如何表示的呢 char**pt(intfloat*) test; 讲到这里有人会质疑以上的应用不相当于脱裤子放p多此一举吗那函数指针到底是如何应用的呢答案当然是有的在函数需要调用另一个函数的时候那么就需要传入函数的地址了在形参部分利用函数指针来接收就需要具体用到函数指针了这里就不多细讲感兴趣的同学可以写一段代码深切体会一下。
3.阅读两段有趣的代码
两段代码源于《C陷阱与缺陷》这本书 (*(void (*)())0)(); //code1void (*signal(int , void(*)(int)))(int); //code2 解释code1对于code1代码(*(void (*)())0)()是将0强制类型转换为void(*)()类型的函数指针这就意味着0地址处放置着一个函数该函数没有参数返回类型为void然后调用0地址处的这个函数。 解释code2对于code2代码void (* signal(int , void(*)(int)) )(int)这个代码是一个函数的声明。 分析首先我们可以确定signal这个符号按优先级来说先和右边的括号结合里面放了一个参数 int另一个参数void(*)(int)由此我们可以判断signal是一个函数它的一个参数为整型变量另一个参数为一个函数指针该函数指针指向的是一个参数为int返回类型为void的函数。那么signal函数还缺什么呢缺返回类型绿色的加粗部分的void(*)(int)表示的就是signal的返回类型。 其实大概可以理解为// void (*) (int) signal(int , void(*)(int))但是语法格式并不支持于是signal只能和*结合在一起。 那么我们可以用typedef这个关键字来简化这段代码使代码变得容易理解。 typedef int* ptr_t;
typedef void(*pf_t)(int);//将void(*)(int) 类型重命名为pf_tpf_t signal(int, pf_t); //将 void(*signal(int,void(*)(int)))(int)的简化六. 函数指针数组 要把函数的地址存到一个数组中那这个数组就叫函数指针数组那函数指针的数组如何定义呢 int (*parr[10])() 解释parr1就是一个数组数组的内容就是int (*)()类型的函数指针 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;
}void menu()
{printf(******************************\n);printf(**** 1. add 2.sub *****\n);printf(**** 3. mul 4.div *****\n);printf(**** 0. exit *****\n);printf(******************************\n);
}
#includestdio.h
int main()
{int input 0;int x 0;int y 0;int ret 0;do{menu();printf(请选择:);scanf(%d, input);switch (input){case 1:printf(请输入两个操作数:);scanf(%d %d, x, y);ret Add(x, y);printf(%d\n, ret);break;case 2:printf(请输入两个操作数:);scanf(%d %d, x, y);ret Sub(x, y);printf(%d\n, ret);break;case 3:printf(请输入两个操作数:);scanf(%d %d, x, y);ret Mul(x, y);printf(%d\n, ret);break;case 4:printf(请输入两个操作数:);scanf(%d %d, x, y);ret Div(x, y);printf(%d\n, ret);break;case 0:printf(退出计算器\n);break;default:printf(选择错误\n);break;}} while (input);return 0;
} 以上代码有没有发现有些许冗余了未来如果有需要添加整型的其他运算如 | ^ ……等运算代码太冗长那有没有什么办法将代码给简化一下呢直接上代码 2.函数指针数组的应用 以下代码改为了转移表的形式转移表主要用指针数组来实现每个元素存一个函数指针我们只要通过已定义好的编号来进行访问。 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;
}
void menu()
{printf(******************************\n);printf(**** 1. add 2.sub *****\n);printf(**** 3. mul 4.div *****\n);printf(**** 0. exit *****\n);printf(******************************\n);
}
#includestdio.h
int main()
{int input 0;int x 0;int y 0;int ret 0;//转移表int (*pfarr[5])(int,int) { NULL,Add,Sub,Mul,Div };//0 1 2 3 4do{menu();printf(请选择:);scanf(%d, input);if (input 1 input 4){printf(请输入两个操作数);scanf(%d %d, x, y);ret pfarr[input](x, y);printf(%d \n, ret);}else if (input 0){printf(退出计算器\n);}else{printf(输入有误\n);}} while (input);return 0;
}
七. 指向函数指针数组的指针 指向函数指针数组的指针是一个 指针该指针指向一个 数组 数组的元素都是 函数指针。 int Add(int x, int y)
{return x y;
}
int Sub(int x, int y)
{return x - y;
}
int main()
{int (*pf)(int, int) Add;//函数指针数组int (* pfArr[4])(int, int) {Add, Sub};//int (*(* ppfArr)[4])(int, int) pfArr;//ppfArr是一个指向函数指针数组的指针变量return 0;
} 以上代码中的int (*(* ppfArr)[4])(int, int)就是一个指向函数指针数组的指针(* ppfArr)可以看出ppfArr是一个指针变量加上[4]说明是一个数组指针指针指向的是一个数组该数组的元素是什么呢剩余部分就是数组的元素类型了函数指针由此我们将其一步步拆开看 其实就是一个指针指向的是一个数组数组的每个元素类型是函数指针。 八. 回调函数 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针地址作为参数传递给另一个函数当这个指针被用来调用其所指向的函数时我们就说这是回调函数。回调函数不是由该函数的实现方直接调用而是在特定的事件或条件发生时由另外的一方调用的用于对该事件或条件进行响应。 什么意思呢
我们将上面函数指针数组部分写的简单计算器觉得冗余的代码应用在此场景作出修改编写如下。
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;
}
void menu()
{printf(******************************\n);printf(*****1.add 2.sub************\n);printf(*****3.mul 4.div************\n);printf(********0.exit ***************\n);printf(******************************\n);
}
void Calc(int (*pf)(int,int))
{int i 0, j 0;printf(请输入两个整数:);scanf(%d %d, i, j);printf(%d\n, pf(i, j));
}
#includestdio.h
int main()
{int input 0;do{menu();printf(请选择:);scanf(%d, input);switch (input){case 1:Calc(Add);case 2:Calc(Sub);case 3:Calc(Mul);case 4:Calc(Div);case 0:printf(退出计算器\n);break;default:printf(输入有误\n);break;}} while (input);return 0;
} 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针地址作为参数传递给另一个函数当这个指针被用来调用其所指向的函数时我们就说这是回调函数。 九、qsort函数的应用
qsort 为quick sort的简写意为快速排序主要用于对各种类型的数组进行排序需要引用头文件stdlib.h中 下面我们来看看它的用法 首先我们在 https://legacy.cplusplus.com/ 网站的旧版本找到对qosrt函数具体规则的描述。 在搜索框搜索qsort显示如下 观察以上图的绿色字体部分就是官方对于qsort函数的声明 void qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*))解释 base -- 指向要排序的数组的第一个元素的指针。num -- 由 base 指向的数组中元素的个数。size -- 数组中每个元素的大小以字节为单位。compar -- 用来比较两个元素的函数qsort可以排序任意类型的数据 如果读者知道冒泡排序的算法是如何实践的我们可能就知道在比较两个整型的时候可以用大于小于操作符来比较在比较字符串的时候我们可以使用strcmp函数但是对于两个结构体数据指定的比较的标准是什么呢 所以我们不妨设计统一的标准使各种类型数组元素都可以进行排序具有通用性。 qsort在声明函数时的参数int (*compar)(const void*, const void*)就是让使用者指定一个比较的方法使用者写一个函数对应此时的函数指针的标准那么compar函数指针的具体规则是什么呢 函数指针指向的函数比较的是两个元素的大小而p1和p2是待排序的两个元素的地址。 如果p1指向的元素小于p2指向的元素则返回值是一个小于0的数值 如果p1指向的元素等于p2指向的元素则返回值是一个等于0的数值 如果p1指向的元素大于p2指向的元素则返回值是一个大于0的数值。 0默认排序为升序若想要排序为降序将p1与p2调换即可 话不多说下面直接上代码。
1.利用qsort来排序整型数组
void print_arr(int arr[], int sz)
{int i 0;for (i 0; i sz; i){printf(%d , arr[i]);}printf(\n);
}
//void表示无具体类型的指针他可以接收任何类型的地址
int compar(const void* p1, const void* p2)
{//使用者在使用的时候需要访问几个字节//就需要进行强制类型转换为指向的元素类型是什么类型的指针//如元素地址是int*类型就需要强制转换为int*return *(int*)p1 - *(int*)p2; //若将p1和p2调换则打印的是降序顺序
}
#includestdlib.h
#includestdio.h
int main()
{int arr[] { 9,8,7,6,5,4,3,2,1,0 };int sz sizeof(arr) / sizeof(arr[0]);//qsort默认排成升序qsort(arr, sz, sizeof(arr[0]), compar);print_arr(arr,sz);return 0;
}
将结果打印 2 利用qsort来排序结构体数据
首先编写一个简单的结构体 struct Stu
{char name[20];int age;
};int main()
{struct Stu s[] { {zhangsan,20},{lisi,18},{wangwu,30}};return 0;
} 按照年龄的大小来排序升序
struct Stu
{char name[20];int age;
};
//按照年龄来排序
int cmp_stu_by_age(const void* p1,const void* p2)
{return ((struct Stu*)p1)-age - ((struct Stu*)p2)-age;
}
#includestdio.h
#includestdlib.h
int main()
{struct Stu s[] { {zhangsan,20},{lisi,18},{wangwu,30}};int sz sizeof(s) / sizeof(s[0]);qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);return 0;
} 按F10调试代码 排序后的结果正是我们想要的结果 数组从小到大排列age分别是18,20,30 按照名字的大小来排序升序
字符串比较大小需要用到strcmp函数在比较字符串时, 按照一位一位进行比较,本质比较的是其字符的ACSII码值若字符串的第一位字符串的ASCII码值与另一个字符串的第一位字符的ASCII码值相等继续向后比较两者的第二位ASCII码值、第三位……以此类推。
strcmp函数的比较规则如下 需要引用头文件string.h 如果字符串1的第n位的ASCII码值大于字符串2的第n位的ASCII码值 则输出结果:1,表示字符串1 字符串2;如果字符串1与字符串2每一位的ASCII码值都相等,而且长度相同, 则输出结果:0 表示字符串1 字符串2字符串1的第n位的ASCII码值小于字符串2的第n位的ASCII码值则输出结果:-1 表示字符串1 字符串2;struct Stu
{char name[20];int age;
};
//按照名字来排序
int cmp_stu_by_name(const void* p1, const void* p2)
{return strcmp(((struct Stu*)p1)-name, ((struct Stu*)p2)-name);
}
#includestdio.h
#includestdlib.h
#includestring.h
int main()
{struct Stu s[] { {zhangsan,20},{lisi,18},{wangwu,30}};int sz sizeof(s) / sizeof(s[0]);qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);return 0;
} 调试代码 排序后的结果正是我们想要的结果 字符串相比较两两元素从第一个字符的ASCII码值进行比较按照元素的大小lwz,第一个字符比较出了结果就不需要进行比较第二个字符ASCII码值的大小了。 十、以冒泡排序的思想模拟实现qsort函数 我们知道了qsort函数的用法下面我们就使用冒泡排序的思想实现一个类似于qsort函数的适用于各种类型的冒泡排序。 先在main函数里将排序的数组和打印内容罗列下来。 #includestdio.h
int main()
{int arr[] { 3,1,5,2,4,9,8,6,5,7 };int sz sizeof(arr) / sizeof(*arr); //sizeof(*arr)表示首元素int i 0;printf(排序前);for (i 0; i sz; i){printf(%d , arr[i]);}printf(\n);bubble_sort(arr, sz, sizeof(*arr), cmp_int);//实现通用的冒泡排序printf(排序后);for (i 0; i sz; i){printf(%d , arr[i]);}return 0;} 下面编写bubble_sort函数的内部逻辑 //以冒泡排序思想模拟实现
//bubble_sort可以排序任意类型数组的数据
void bubble_sort(void* base,int num,int width,int (*cmp)(const void* p1, const void* p2))
{int i 0;//趟数for (i 0; i num - 1; i){int flag 1;//假设该趟数有序//每趟冒泡排序的过程int j 0;for (j 0; j num - 1 - i; j){//两两元素进行比较//将base强转为char* j乘以每个元素的大小 相当于跳过了j*width个字节//将base强转为char* j 1乘以每个元素的大小 相当于跳过了(j1)*width 个字节if (cmp_int((char*)base j * width, (char*)base (j 1) * width) 0){flag 0;//有交换就置为0//交换//封装一个Swap函数用来交换元素Swap((char*)base j * width, (char*)base (j 1) * width, width);}}if (flag 1)break;}
} 将两个元素的交换部分封装一个Swap函数专门在这个函数里面编写。 //传过来的是char*类型如果要修改元素的大小则需要将元素的每个字节进行交换
//所以这里也就是为什么要将width传递过来的原因了。
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;}
} 最后使用者自己编写一个比较元素的大小的函数。 int cmp_int(const void* p1,const void* p2)
{return *(int*)p1 - *(int*)p2;
} 最后将整体代码放在下面。
int cmp_int(const void* p1,const void* p2)
{return *(int*)p1 - *(int*)p2;
}
//传过来的是char*类型如果要修改元素的大小则需要将元素的每个字节进行交换
//所以这里也就是为什么要将width传递过来的原因了。
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;}
}
//以冒泡排序思想模拟实现
//bubble_sort可以排序任意类型数组的数据
void bubble_sort(void* base,int num,int width,int (*cmp)(const void* p1, const void* p2))
{int i 0;//趟数for (i 0; i num - 1; i){int flag 1;//假设该趟数有序//每趟冒泡排序的过程int j 0;for (j 0; j num - 1 - i; j){//两两元素进行比较//将base强转为char* j乘以每个元素的大小 相当于跳过了j*width个字节//将base强转为char* j 1乘以每个元素的大小 相当于跳过了(j1)*width 个字节if (cmp_int((char*)base j * width, (char*)base (j 1) * width) 0){flag 0;//有交换就置为0//交换//封装一个Swap函数用来交换元素Swap((char*)base j * width, (char*)base (j 1) * width, width);}}if (flag 1)break;}
}
#includestdio.h
int main()
{int arr[] { 3,1,5,2,4,9,8,6,5,7 };int sz sizeof(arr) / sizeof(*arr); //sizeof(*arr)表示首元素int i 0;printf(排序前);for (i 0; i sz; i){printf(%d , arr[i]);}printf(\n);bubble_sort(arr, sz, sizeof(*arr), cmp_int);//实现通用的冒泡排序printf(排序后);for (i 0; i sz; i){printf(%d , arr[i]);}return 0;} 最后将代码打印达到了我们实现的效果。 创作不易请给波支持点赞关注再走吧嘿~~~
