前言：指针的主题，我们在初阶的《指针》章节已经接触过了，我们知道了指针的概念：
1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2.指针的大小是固定的4/8个字节(32位平台/64位平台)。
3.指针是有类型的，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
4.指针的运算。
目录
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来改正冒泡排序
1. 字符指针
在指针的类型中我们知道有一种指针类型为字符指针char*;
笔记：
内存会划分字节为单位的空间，每个字节都有一个编号(地址/指针)，
指针/地址要被存储起来，需要一个空间，这个空间就是指针变量！
指针（变量）。
一般使用方式：
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}还可以怎么使用呢，如下:
int main()
{
const char* pstr = "hello bit."; //这里是把一个字符串放到pstr指针变量里了吗？
printf("%s\n", pstr);
return 0;
}代码 const char* pstr = "hello bit.";
特别容易让同学以为是把字符串hello bit放到字符指针pstr里了，但是-本质上是把字符串hello bit,首字母的地址放到了pstr中。
#include <stdio.h>
int main O
{
char str1[] = "hell o bit.";
char str2[] = "hello bit.";
const char *str3 = "hell o bit.”;
const char *str4 = "hello bit.”;
if(str1 == str2)
printf("strl and str2 are same\n");
else
printf("str1 and str2 are not same\n") ;
if(str3 == str4)
printf("str3 and str4 are same\n“);
else
printf("str3 and str4 are not same\n");
return 0;
}这里最终输出的是：
注： 这里str3和str4指向的是一个同一个常量字符串。 C/C++会把常量字符串存储到单独的一个内存区域， 当几个指针，指 向同一个字符串的时候， 他 们 实际会指向同一块内存，但是用相同的常量字符串去初始化不同的数组的 时 候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。
2.指针数组
1. int* arr1 [ 10 ]; // 整形指针的数组2. char * arr2 [ 4 ]; // 一级字符指针的数组3. char ** arr3 [ 5 ]; // 二级字符指针的数组
重要：
整形数组 - 存放整形的数组
字符数组 - 存放字符的数组
指针数组 - 存放指针的数组
数组指针 - 指向数组的指针。
3. 数组指针
3.1 数组指针的定义
数组指针是指针？还是数组？
答案是：指针。（指向数组的指针）
整型指针： int* pint; 能够指向整形数据的指针。
浮点型指针：float* pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。
int * p1 [ 10 ];>>p1 -> 是一个指针数组，存放的是指针数组，存放类型为int* .int ( * p2 )[ 10 ];>>p2 -> 是一种数组指针，存放的是数组指针，存放元素类型int。//p1, p2 分别是什么？
p1存放的是第一个元素的地址，p1+1 - 跳过一个int ，*p 访问一个int数据4个字节。p2存放的是arr数组的地址，p2+1 - 跳过了整个数组，*p2访问到的是arr数组，*p2等价于arr了，那么*p2就是数组名了，数组名有相当于首元素的地址，所以*p2本质上是arr数组第一个元素的地址。
int ( * p )[ 10 ];//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
3.2 &数组名VS数组名
int arr[10];#include <stdio.h>
int main()
{
int arr[10] = {0};
printf("%p\n", arr);
printf("%p\n", &arr);
return 0;
}运行结果如下：
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr = %p\n", arr);
printf("&arr= %p\n", &arr);
printf("arr+1 = %p\n", arr+1);
printf("&arr+1= %p\n", &arr+1);
return 0;
}运行结果如下：
根据上面的代码我们发现，其实 &arr 和 arr ，虽然值是一样的，但是意义应该不一样的。实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
//数组的地址存起来，就应该放在数组指针中!
int (*p)[10] = &arr;
3.3 数组指针的使用
#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
//但是我们一般很少这样写代码
return 0;
}#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
int i = 0;
for(i=0; i<row; i++)
{
for(j=0; j<col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print_arr2(int (*arr)[5], int row, int col)
{
int i = 0;
for(i=0; i<row; i++)
{
for(j=0; j<col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
print_arr1(arr, 3, 5);
//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
//可以数组指针来接收
print_arr2(arr, 3, 5);
return 0;
}学习了指针数组和数组指针，解读下下面代码的意思：
int arr [ 5 ];arr 是一个整型数组，5个元素，每个元素类型为int。int * parr1 [ 10 ];parr1 是一个数组，有10个元素，每个元素的类型是 int* ,所以parr1是指针数组。int ( * parr2 )[ 10 ];parr2 和 * 结合，说明parr2是一个指针，该指针指向一个数组，数组是10个元素，每个元素是int类型的。所以 parr2是数组指针。int ( * parr3 [ 10 ])[ 5 ];parr3 和 [] 结合，说明parr3是一个数组，数组是10个元素，数组的每个元素是什么类型呢？是一种数组指针，类型是int(*)[5] . 该类型的指针指向有5个int 类型的元素。（[ ] 优先级高于 * ）
那怎么打印数组呢，根据之前学的内容：
int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; //最简单的方法，*(p + i)，直接首元素地址去打印，然后加一，往后跳去打印 int*p = arr; int i = 0; for (i = 0; i < 10; i++) { printf("%d ", *(p + i)); } return 0; }当用数组指针来写的话：
//用数组指针， 这样不如下面用首元素的地址往后跳，找到数组的地址，然后用下标 int (* p)[10] = &arr; int i = 0; for (i = 0; i < 10; i++) { printf("%d ", (*p)[i]); }但是有点大材小用了，我们再来看二维数组中的使用，会不会比以前的方法变的简单呢
void print1(int arr[3][4], int row, int col) { int i = 0; for (i = 0; i < row; i++) { int j = 0; for (j = 0; j < col; j++) { printf("%d ", arr[i][j]); //i行j列去打印，二维数组的普通打印用下标 } printf("\n"); } }我们用数组指针来写
void print2(int(*p)[4], int row, int col) { int i = 0; for (i = 0; i < row; i++) { int j = 0; for (j = 0; j < col; j++) { printf("%d ", (*(p + i))[j]); //先拿到数组指针找到这个数组，p是指针哪一行的，加i就是找到所有的行，然后再加上一个下标 } printf("\n"); } }打印的时候还有一种写法
printf("%d ", p[i][j]);//这样写也是可以的，直接找到整个数组第一行地址，然后往后下一行，每一行的下标j，找到所有元素
4. 数组参数、指针参数
4.1 一维数组传参
数组传参的时候，形参写成数组形式。--- ok
#include<stdio.h>
void test1()//如何传参数？
void test2()//如何传参数？
int main()
{
int arr1[10] = { 0 };
int* arr2[20] = { 0 };
test1(arr1);
test2(arr2);
}参数可以这样写：
#include <stdio.h>
void test(int arr[])//ok? //ok 可以传参
{}//函数中arr传来，数组传参，参数的部分写为数组
void test(int arr[10])//ok? //ok
{}//函数中arr传来，数组传参，参数的部分写为数组，定义个大小也是可以的
void test(int *arr)//ok? //ok
{}//函数中arr传来，是首元素地址，每个元素都整型，数组传参，也可以用指针接受，所有用整型指针来接收
void test2(int *arr[20])//ok? //ok
{}//函数中arr2传来，是首元素地址，arr2是数组里面放的指针，传来后，用指针数组来接受地址
void test2(int **arr)//ok? //ok{}//函数中arr2传来，是首元素地址，arr2是数组里面放的指针，形参里面的*arr，就是数组首元素地址解引用，就是数组，所有**arr就可以接收传来的指针
void test2(int* arr)
{}//这样是不行的，传来的数组名是首元素地址，都是指针，所有我们接收的时候也要二级指针
4.2 二维数组传参
void test(int arr[3][5])//ok？ //ok
{} //形参传是二维数组，行是可以省略的，但是列不能省略。
void test(int arr[][])//ok？ //not ok - 不可传参
{}//列不可以省略
void test(int arr[][5])//ok？ //ok
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//ok？ //error 整型指针
{}
void test(int* arr[5])//ok？ //error 数组
{}
void test(int (*arr)[5])//ok? //ok 指针数组
{}
void test(int **arr)//ok？//error
{}
int main()
{
int arr[3][5] = {0};
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;
}当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
比如：
void test1 ( int * p ){}//test1 函数能接收什么参数？//test2函数能接收一个指向整形的指针作为参数;//eg:具体数据类型的指针，指向结构体的指针，指向数组的指针，函数指针。void test2 ( char* p ){}//test2 函数能接收什么参数？//test2函数能接收一个指向字符的指针作为参数;//eg:字符串字面量，字符数组，单个字符。
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;
}当函数的参数为二级指针的时候，可以接收什么参数？eg:1.指向指针的指针；2.指向数组的指针的指针；3.指向结构体的指针的指针；4.函数指针的指针；
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;
}5. 函数指针
//函数指针//函数其实也是有地址的，函数名(或者&函数名)就是函数的地址；
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}结果：
输出的是两个地址，这两个地址是 test 函数的地址。
void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();pfun1 可以存放。 pfun1 先和 * 结合，说明 pfun1 是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void 。
#include<stdio.h>
int main()
{
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int, void(*)(int)))(int);
return 0;
}// 代码 1( * ( void ( * )()) 0 )();//( void ( * )()) - 函数指针类型//把0强制转换为一种函数指针类型，无参无返回类型；这段代码的意思是是将0强制类型转化为void (*)()类型的函数指针，然后再去调用0地址处的这个函数；
// 代码 2void ( * signal(int , void(*)(int )))( int );//signal 是一个函数声明，声明的函数名字是signal，signal 的参数有2个，第一个是int类型，第二个是函数指针:void(*)(int)，该指针指向的函数参数int， 返回类型是void。//signal 函数的返回类型也是函数指针，该指针指向的函数参数int , 返回类型是void .
//void (*p)(int) ; //p 是函数指针变量的名字
//typedef void(*pf_t)(int) ; //pf_t 是类型名
void (*signal(int, void(*)(int) ) )(int);
该代码是一次函数的声明，声明的函数名字叫signal
signal函数的参数有2个，第一个是int类型，第二个是函数指针类型
该函数指针能够指向的那个函数的参数是int，返回类型是void
signal函数的返回类型是一个函数指针
该函数指针能够指向的那个函数的参数是int, 返回类型是void
相当于三个套娃函数指针
简化一下（typedef）类型简化，typedef unsigned int uint;（简化方法）
typedef void(*pf_t)(int); //pfun_t就是函数指针的类型
pf_t signal(int, pf_t);//这就是简化完，
6. 函数指针数组
int * arr [ 10 ];// 数组的每个元素是 int*
int ( * parr1 [ 10 ])();int * parr2 [ 10 ]();int ( * )() parr3 [ 10 ];
答案是： parr1parr1 先和 [] 结合，说明 parr1 是数组，数组的内容是什么呢？是 int (*)() 类型的函数指针。函数指针数组的用途： 转移表
#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; } int main() { int x, y; int input = 1; int ret = 0; 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: printf( "输入操作数：" ); scanf( "%d %d", &x, &y); ret = add(x, y); printf( "ret = %d\n", ret); break; case 2: printf( "输入操作数：" ); scanf( "%d %d", &x, &y); ret = sub(x, y); printf( "ret = %d\n", ret); break; case 3: printf( "输入操作数：" ); scanf( "%d %d", &x, &y); ret = mul(x, y); printf( "ret = %d\n", ret); break; case 4: printf( "输入操作数：" ); scanf( "%d %d", &x, &y); ret = div(x, y); printf( "ret = %d\n", ret); break; case 0: printf("退出程序\n"); breark; default: printf( "选择错误\n" ); break; } } while (input); return 0; }使用函数指针数组的实现
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; } //函数指针数组存放上述函数的地址 //但是也限定死了，只能是两个整型的操作数才能 //需要注意的是，我设置的计算是1，2，3，4，进入计算，所以第一个函数指针设置为0，后面对应1，2，3，4 int main() { int input = 0; int x = 0; int y = 0; int (*p[5])(int, int) = { NULL, Add, Sub, Mul, Div }; int ret = 0; do { menu(); printf("请选择:>"); scanf("%d", &input); //也需要判断我们输入的数进行选择 if (input == 0) { printf("退出计算器\n"); break; } else if (input >= 1 && input <= 4) { //直接用函数指针数组，用函数指针，直接进入到函数里，用不用*都一样 printf("请输入两个操作数:>"); scanf("%d %d", &x, &y); ret = pf[input](x, y); printf("ret = %d\n", ret); } else { printf("选择错误\n"); } } while (input); return 0; }
7. 指向函数指针数组的指针
int my_strlen(const char* str)
{
return 0;
}
int main()
{
//指针数组
char* ch[5];
int arr[10] = {0};
//pa是数组指针
int (*pa)[10] = &arr;
//pf是函数指针
int (*pf)(const char*) = &my_strlen;
//函数指针数组
int (*pfA[5])(const char*) = { &my_strlen };
return 0;
}定义：int (*parr1[10])(); parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？
是 int (*)() 类型的函数指针。
//首先，函数指针数组是数组
parr[];
//数组的每个元素是函数指针,以无参函数，且无返回值的函数为例
void (*) ();
//结合后
void (*) () parr[];
//规范的写法
void (*parr[])()
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. 回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
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;
}
//回调函数，写一个函数指针指向函数，传进来都是计算用的函数指针
//把我计算用的这些Add，Sub等等这些函数，传给calc这个函数，然后用clac函数参数的部分是函数指针
//这个clac函数通用了，可以加减乘除，就看传谁的地址，通过传来的函数地址，去找到这个函数
void calc(int (*pf)(int, int))
{
int x = 0;
int y = 0;
int ret = 0;
printf("请输入两个操作数:>");
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);
//把Add这个函数地址传给clac里面，就是pf这个函数指针，这个pf函数指针指向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;
}思路：先写一个calc函数，参数用函数指针来接受，前面写的有功能函数，在主函数中，调用calc函数，把功能函数的地址传到calc函数中，calc函数正好用函数指针来接受，calc函数中指针pf通过传来的功能函数地址，找到这些函数，去进行计算，然后返回值再打印，相当于calc就是一个实现计算过程的模型。
8.1.冒泡排序
两两相邻函数进行比较：(从小到大排序)
缺点：只能排序整数
void bubble_sort(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;
}
}
}
}
int main()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}8.2.qsort函数
void qsort(void* base, //待排序的数组的起始地址
size_t num, //元素个数
size_t width, //一个元素的大小
int (*cmp)(const void* e1, const void* e2)//两个元素的比较函数
);首先演示一下qsort函数的使用：
#include <stdio.h>
//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void* p1, const void* p2)
{
return (*( int *)p1 - *(int *) p2);
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz , sizeof (int), int_cmp);
for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%d ", arr[i]);
}
printf("\n");
return 0;
}qsort就是这样实现的，把你提供的函数 cmp_int 地址传到qsort，qsort里用函数指针去接收，然后去指向这个函数，也就是一个回调函数，e1，e2，是要比较的这两个元素的地址，e1<e2返回小于零的数
8.3.用qsort来改正冒泡排序
冒泡排序可以排任何类型的，进行改造，怎么改
第一层循环是不变的，内部两两比较也不变，变的是判断，整型大小比较才能用大小号，字符或者浮点型比较方法不一样，当我们想让这个冒泡排序任何地方使用，是不是就是把比较的部分抽出来，你想排序整型，你自己提供一个排序整型的方法，想排序啥样的，就提供什么样子的
函数1是用库函数qsort排序整型
函数2是用库函数qsort排序结构体
函数3是用冒泡排序模拟实现库函数qsort排序整型
函数4是用冒泡排序模拟实现库函数qsort排序结构体
int cmp_int(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
//参数是无类型的指针来接受，所以这里要强制类型转化为int，然后再解引用
}
//对于整型的排序
void test1()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
//先定义一个结构体
struct Stu
{
char name[20];
int age;
};
//先对结构体的年龄比较
int cmp_stu_by_age(const void* e1, const void* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
//参数是无类型的指针来接受，所以这里要强制类型转化为struct Stu*，相当于拿到了结构体指针，然后再箭头指向年龄
}
//再对结构体的名字比较
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
//参数是无类型的指针来接受，所以这里要强制类型转化为struct Stu*，相当于拿到了结构体指针，然后再箭头指向名字
//名字比是字符串比较不能用减号了，用函数strcmp，比较对应位置上的字符，strcmp返回值跟qsort返回值一样的
}
//对于结构体的排序
void test2()
{
//结构体的描述
struct Stu s[3] = { {"zhangsan",20}, {"lisi", 50}, {"wangwu", 33} };
int sz = sizeof(s) / sizeof(s[0]);
qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
上面test1和test2是用库函数qsort来排序整型和结构体
上面test3和test4是用冒泡排序的思想模拟实现qsort来排序整型和结构体
//改造冒泡排序函数，使得这个函数可以排序任意指定的数组
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
//为了能接收各种类型所以void* base，sz就是元素的个数， width宽度你只知道个数，宽度为了知道几个字节，最后用函数指针用来，在这个函数中指针接收要比较的地址
{
size_t i = 0;
for (i = 0; i < sz - 1; i++)
{
size_t j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
//这里是找我们要比较的那俩地址，最开始是base，我们用width去找这一对，往后跳对应字节去找，用j可以找后面所有的要比较的数了
//然后这俩地址传给e1，e2，就是通过指针找到比较函数
{
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
//交换，交换函数，先把这俩地址给我，再把宽度给我
}
}
}
}
//交换函数，用char接收，然后也接收宽度，交换的细节，是一个字节的交换，不是整个的交换，然后往后跳
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 test3()
{
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);
//我们arr传给base，最开始的地址是base，第二个是加上一个，但是是无类型的，要给她类型
//但是给他什么类型，也不能写死，所以我们用我们写的宽度，单位是字节，所以我们转化为char的指针
//然后我找base后面的地址，就可以用字节（宽度）跳过
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
//使用我们自己写的bubble_sort函数排序结构体数组
//结构体的时候跟上面的是一样的
void test4()
{
struct Stu s[3] = { {"zhangsan",20}, {"lisi", 50}, {"wangwu", 33} };
int sz = sizeof(s) / sizeof(s[0]);
bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);
bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
int main()
{
//用库函数qsort实现排序
test1();//整型
test2();//结构体
//自己用冒泡排序的思想模拟实现qsort
test3();//整型
test4();//结构体
return 0;
}函数1，函数2，就是我们上面用库函数来进行排序，很方便，只要我们创建一个类型函数，是要去排序整型还是结构体还是其他的，我们去创建一个，然后用函数指针去接收；
函数3，函数4，就是我们用冒牌排序的思想模拟实现这个库函数，在分析一下。
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
传要排序的数组，个数，字节，还有我们提供的函数地址
bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);
bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
结构体也是一样的，要传过去什么，最重要的是我们提供的函数
首先就是用什么去接收
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
为了能接收各种类型所以void* base，sz就是元素的个数， width宽度你只知道个数，宽度为了知道几个字节，最后用函数指针用来，在这个函数中指针接收要比较的地址
然后就是去判断两个比较数
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
这里是找我们要比较的那俩地址，最开始是base，我们用width去找这一对，往后跳对应字节去找，用j可以找后面所有的要比较的数了，然后这俩地址传给e1，e2，就是通过指针找到比较函数
判断完去交换位置
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
交换，交换函数，先把这俩地址给我，再把宽度给我
思路：
当我们整体看的时候，我们先进入到test3函数中，到我们的冒泡排序bubble_sort中传入数据
传到cmp_int时候，是把cmp_int函数的地址传到bubble_sort函数中的参数int(*cmp)(const void* e1, const void* e2)函数指针中，也就是cmp
所以我bubble_sort函数中的cmp指针指向的就是cmp_int函数，然后我们开始进入循环然后到判断，利用base和wide宽度找到要比较的两个数的地址
由cmp指针指向到cmp_int函数（把这俩比较数的地址传来，给e1，e2）然后算出返回值，然后看是否进行交换，进入到swap交换函数中去交换。
// 一维数组int a [] = { 1 , 2 , 3 , 4 };printf ( "%d\n" , sizeof ( a ));//数组名a单独放在sizeof内部，计算的是整个数组的大小，单位是字节，4*4=16；printf ( "%d\n" , sizeof ( a + 0 ));//a表示数组首元素地址，a+0还是数组首元素的地址，是地址大小4/8;printf ( "%d\n" , sizeof ( * a ));//a表示的首元素的地址，*a就是对首元素的地址的解引用，就是首元素，大小为4字节；printf ( "%d\n" , sizeof ( a + 1 ));//a表示首元素的地址，a+1是第二个元素的地址，是地址，大小就是4/8个字节；printf ( "%d\n" , sizeof ( a [ 1 ]));//a[1]是第二个元素，大小是4个字节；printf ( "%d\n" , sizeof ( & a ));//&a表示的是数组的地址，但也是地址，地址大小就是4/8个字节；printf ( "%d\n" , sizeof ( *& a ));printf ( "%d\n" , sizeof ( & a + 1 ));printf ( "%d\n" , sizeof ( & a [ 0 ]));printf ( "%d\n" , sizeof ( & a [ 0 ] + 1 ));// 字符数组char arr [] = { 'a' , 'b' , 'c' , 'd' , 'e' , 'f' };printf ( "%d\n" , sizeof ( arr ));printf ( "%d\n" , sizeof ( arr + 0 ));printf ( "%d\n" , sizeof ( * arr ));printf ( "%d\n" , sizeof ( arr [ 1 ]));printf ( "%d\n" , sizeof ( & arr ));printf ( "%d\n" , sizeof ( & arr + 1 ));printf ( "%d\n" , sizeof ( & arr [ 0 ] + 1 ));printf ( "%d\n" , strlen ( arr ));printf ( "%d\n" , strlen ( arr + 0 ));printf ( "%d\n" , strlen ( * arr ));printf ( "%d\n" , strlen ( arr [ 1 ]));printf ( "%d\n" , strlen ( & arr ));printf ( "%d\n" , strlen ( & arr + 1 ));printf ( "%d\n" , strlen ( & arr [ 0 ] + 1 ));char arr [] = "abcdef" ;printf ( "%d\n" , sizeof ( arr ));printf ( "%d\n" , sizeof ( arr + 0 ));printf ( "%d\n" , sizeof ( * arr ));printf ( "%d\n" , sizeof ( arr [ 1 ]));printf ( "%d\n" , sizeof ( & arr ));printf ( "%d\n" , sizeof ( & arr + 1 ));printf ( "%d\n" , sizeof ( & arr [ 0 ] + 1 ));printf ( "%d\n" , strlen ( arr ));printf ( "%d\n" , strlen ( arr + 0 ));printf ( "%d\n" , strlen ( * arr ));printf ( "%d\n" , strlen ( arr [ 1 ]));printf ( "%d\n" , strlen ( & arr ));printf ( "%d\n" , strlen ( & arr + 1 ));printf ( "%d\n" , strlen ( & arr [ 0 ] + 1 ));char * p = "abcdef" ;printf ( "%d\n" , sizeof ( p ));printf ( "%d\n" , sizeof ( p + 1 ));printf ( "%d\n" , sizeof ( * p ));printf ( "%d\n" , sizeof ( p [ 0 ]));printf ( "%d\n" , sizeof ( & p ));printf ( "%d\n" , sizeof ( & p + 1 ));printf ( "%d\n" , sizeof ( & p [ 0 ] + 1 ));printf ( "%d\n" , strlen ( p ));printf ( "%d\n" , strlen ( p + 1 ));printf ( "%d\n" , strlen ( * p ));printf ( "%d\n" , strlen ( p [ 0 ]));printf ( "%d\n" , strlen ( & p ));printf ( "%d\n" , strlen ( & p + 1 ));printf ( "%d\n" , strlen ( & p [ 0 ] + 1 ));// 二维数组int a [ 3 ][ 4 ] = { 0 };printf ( "%d\n" , sizeof ( a ));printf ( "%d\n" , sizeof ( a [ 0 ][ 0 ]));printf ( "%d\n" , sizeof ( a [ 0 ]));printf ( "%d\n" , sizeof ( a [ 0 ] + 1 ));printf ( "%d\n" , sizeof ( * ( a [ 0 ] + 1 )));printf ( "%d\n" , sizeof ( a + 1 ));printf ( "%d\n" , sizeof ( * ( a + 1 )));printf ( "%d\n" , sizeof ( & a [ 0 ] + 1 ));printf ( "%d\n" , sizeof ( * ( & a [ 0 ] + 1 )));printf ( "%d\n" , sizeof ( * a ));printf ( "%d\n" , sizeof ( a [ 3 ]));
1. sizeof( 数组名 ) ，这里的数组名表示整个数组，计算的是整个数组的大小。2. & 数组名，这里的数组名表示整个数组，取出的是整个数组的地址。3. 除此之外所有的数组名都表示首元素的地址。
结束语
指针有很多需要学习的地方，本文有借鉴前人经验，非常感谢。。。
![[Java] 使用 VSCode 来开发 Java](https://i-blog.csdnimg.cn/direct/45a6b5c90c9d469ea7c2bad3ef197bbc.png)
