学习目标：
1. 字符指针
2. 指针数组
3. 数组指针
4. 数组传参和指针传参
5. 函数指针
6. 函数指针数组
7. 指向函数指针数组的指针
8. 回调函数
指针：
指针可以理解为：
字符指针：
定义：字符指针 char*。
字符指针的使用：
//使用1
int main ()
{
char ch = 'w' ;
char * pc = & ch ;
* pc = 'w' ;
return 0 ;
}
//使用2
int main ()
{
const char* pstr = "hello bit." ;//把一个常量字符串的 首字符 h 的地址 存放到指针变量 pstr 中
printf ( "%s\n" , pstr );
return 0 ;
}
练习：
指针数组：
概念：指针数组是一个存放指针的数组。
int* arr1 [ 10 ]; // 整形指针的数组
char * arr2 [ 4 ]; // 一级字符指针的数组
char ** arr3 [ 5 ]; // 二级字符指针的数组
实现模拟二维数组：
数组指针：
概念：能够指向数组的指针。(可以理解为先与指针结合再与数组结合)
int (*p)[10];
// 解释： p先和*结合，说明p是一个指针变量 ，然后指着指向的是一个大小为 10 个整型的数组。所以 p 是一个指针，指 向一个数组，叫数组指针。
// 这里要注意： [ ] 的优先级要高于 * 号的，所以必须加上（）来保证 p 先和 * 结合。
值得注意的是：
数组名的理解:数组名是数组首元素的地址
有2个例外：
1. sizeof(数组名)，这里的数组名不是数组首元素的地址，数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节
2. &数组名，这里的数组名表示整个数组， &数组名取出的是整个数组的地址
除此之外，所有的地方的数组名都是数组首元素的地址
数组指针一般用于二维数组：
数组的传参：
二维数组的每一行可以理解为二维数组的一个元素，每一行又是一个一维数组，所以二维数组其实是一维数组的数组。
二维数组的数组名，也是数组名，数组名就是数组首元素的地址。
arr----首元素的地址；
arr----第一行的地址；
arr----一维数组的地址即数组的地址。
一维数组传参：
二维数组的传参：
总结:二维数组传参，函数形参的设计只能省略第一个[ ]的数字因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素这样才方便运算。
指针的传参：
一级指针传参：
二级指针的传参：
函数指针：
概念：指向函数的指针。
int (*pf)(int, int) = &Add;
//pf是函数指针变量
//int (*)(int, int) 是函数指针类型
void test(char* pc, int arr[10]) { } int main() { void (*pf)(char *, int [10]) = test; return 0; }
由上图可知：
函数名是函数的地址；
&函数名也是函数的地址。
阅读两段有趣的代码：
//代码1
( * ( void ( * )()) 0 )();
解析：调用0地址处的函数
1. 将0强制类型转换为void (*)() 类型的函数指针
2. 调用0地址处的这个函数
//代码2
void ( * signal ( int , void ( * )( int )))( int );
解析：
1.signal 是一个函数声明
2.signal 函数有2个参数，第一个参数的类型是int，第二个参数的类型是 void(*)(int) 函数指针类型
3.该函数指针指向的函数有一个int类型的参数，返回类型是void
4.signal 函数的返回类型也是void(*)(int) 函数指针类型,该函数指针指向的函数有一个int类型的参数，返回类型是void
类型重定义：typedef
//类型重定义1 typedef unsigned int uint; typedef int* ptr_t; int main() { uint u1; ptr_t p1; int* p2; return 0; } //类型重定义2 typedef int(*parr_t)[10]; typedef int (*pf_t)(int, int) ; int main() { typedef void(*pf_t)(int); pf_t signal(int, pf_t); //上方两句将下方的语句简化，效果相同 void (* signal(int, void(*)(int) ) )(int); return 0; }
函数指针数组：
定义：int (*parr1[10])(); 每个元素都是函数指针类型。
用途：转移表。
函数指针数组的使用：
#include <stdio.h> #include <string.h> 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"); } //实现int类型的加减乘除 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 4 do { menu(); printf("请选择:>"); scanf("%d", &input); if (input >= 1 && input <= 4) { printf("请输入两个操作数:"); scanf("%d %d", &x, &y); ret = pfArr[input](x, y); printf("ret = %d\n", ret); } else if(input == 0) { printf("退出计算器\n"); } else { printf("选择错误，重新选择\n"); } } while (input); return 0; }
指向函数指针数组的指针：
定义：
指向函数指针数组的指针是一个 指针 指针指向一个 数组 ，数组的元素都是 函数指针 ; （一般不直接写，通过函数指针一步一步变化得到，可以减少失误操作）
void (*pf)(const char*) = test; //pf是函数指针变量
void (*pfArr[10])(const char*); //pfArr是存放函数指针的数组
void (* (*p) [10])(const char*) = &pfArr;//p指向函数指针数组的指针
回调函数：
概念：
回调函数就是一个通过函数指针调用的函数。如果你把 函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数 时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
//回调函数的使用
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("ret = %d\n", ret);
}
使用回调函数模拟实现qsort()函数：
base:指向要排序的数组的第一个对象的指针，转换为 .void*。
num:数组中由指向的元素个数。是无符号整型。
size:数组中每个元素的大小（以字节为单位），是无符号整型。
compar:指向比较两个元素的函数的指针，重复调用此函数以比较两个元素。
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; qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp); for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++) { printf( "%d ", arr[i]); } printf("\n"); return 0; }
排序int类型：
#include <stdio.h> //比较int类型的比较函数 int my_compare(const void* q1, const void* q2) { return (*(int*)q1 - *(int*)q2); } //交换每一个字节的元素 void Swap(char* b1, char* b2, int size) { int i = 0; for (i = 0; i < size; i++) { char tmp = *b1; *b1 = *b2; *b2 = tmp; b1++; b2++; } } //模拟实现自己的qsort()函数 void my_qsort(void* base, int num, int size, int (*my_compare)(const void* q1, const void* q2)) { int i = 0; int j = 0; for (i = 0; i < num - 1; i++) { for (j = 0; j < num - 1 - i; j++) { //从小到大排序 if (my_compare((char*)base+j*size,(char*)base+(j+1)*size) > 0) { Swap((char*)base + j*size, (char*)base + (j + 1)*size, size); } } } } int main() { int arr[10] = { 2,4,6,7,8,3,1,0,9,5 }; int sz = sizeof(arr) / sizeof(arr[0]); my_qsort(arr, sz, sizeof(arr[0]), my_compare); return 0; }
排序结构体类型：
#include <string.h> //创建学生结构体 struct Stu { char name[20]; int age; }; //比较int类型的比较函数 int my_compare_age(const void* q1, const void* q2) { return ((struct Stu*)q1)->age - ((struct Stu*)q2)->age; } //比较int类型的比较函数 int my_compare_name(const void* q1, const void* q2) { return strcmp( ( (struct Stu*)q1 )->name ,( (struct Stu*)q2 )->name); } //交换每一个字节的元素 void Swap(char* b1, char* b2, int size) { int i = 0; for (i = 0; i < size; i++) { char tmp = *b1; *b1 = *b2; *b2 = tmp; b1++; b2++; } } //模拟实现自己的qsort()函数 void my_qsort(void* base, int num, int size, int (*my_compare)(const void* q1, const void* q2)) { int i = 0; int j = 0; //趟数 for (i = 0; i < num - 1; i++) { //一趟内部比较的对数 for (j = 0; j < num - 1 - i; j++) { //从小到大排序 if (my_compare((char*)base + j * size, (char*)base + (j + 1) * size) > 0) { //交换 Swap((char*)base + j * size, (char*)base + (j + 1) * size, size); } } } } int main() { struct Stu arr[] = { {"zhangsan",34},{"lisi",27},{"wanwu",20} }; int sz = sizeof(arr) / sizeof(arr[0]); my_qsort(arr, sz, sizeof(arr[0]), my_compare_age); my_qsort(arr, sz, sizeof(arr[0]), my_compare_name); return 0; }
以上就是个人学习指针的个人见解和学习的解析，欢迎各位大佬在评论区探讨！
感谢大佬们的一键三连！ 感谢大佬们的一键三连！ 感谢大佬们的一键三连！
