-
c语言分层理解（c语言指针（下））
1.指针数组和数组指针区分
指针数组是存放指针的数组，实质上是数组。数组指针是指向数组的指针，实质上是指针。
1.1指针数组
比如int* arr[10];这里怎么理解，这里的arr[10 ]就是数组，数组中存放的是int类型的指针。
用例子来说：
#includeint main() { char* arr[3] = { "zhangsan","lisi","wangwu" }; int i = 0; for (i = 0; i < 3; i++) { printf("%s\n", arr[i]); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
#includeint main() { int arr1[5] = { 1,2,3,4,5 }; int arr2[5] = { 2,3,4,5,6 }; int arr3[5] = { 3,4,5,6,7 }; int* arr[3] = { arr1,arr2,arr3 }; int i = 0; int j = 0; for (i = 0; i < 3; i++) { for (j = 0; j < 5; j++) { printf("%d", arr[i][j]); } printf("\n"); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
1.2数组指针
比如int (*arr)[10];这里的意思是arr是个指针，这个指针指向一个数组，数组中有十个元素，每个元素都是int类型。这里可以借用int *arr;类比，这里的意思是指向整型的指针变量arr。
这里需要注意的是&arr和arr,认识到这个数组指针，这里对其再次解读。
这里的&arr的类型是int (*)[10];是一个数组指针类型，其他的是整型指针类型，所以&arr+1跳过的是整个数组。打印一维数组元素：
#includevoid print(int(*p)[10], int sz) { int i = 0; for (i = 0; i < sz; i++) { //p=&arr,*p=arr printf("%d ", (*p)[i]); } } int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int sz = sizeof(arr) / sizeof(arr[0]); print(&arr, sz); return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
打印二维数组：
#includevoid print(int (*p)[5], int r,int c) { int i = 0; int j = 0; for (i = 0; i < r; i++) { for (j = 0; j < c; j++) { printf("%d ", *(*(p + 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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
再来看看这个是什么鬼？
int (*parr[10])[5];
这个是什么东西？
首先它可拆分为两个int (* )[5]和parr[10]，这里的意思是 parr是存放数组指针的数组。2.数组参数和指针参数
2.1一维数组传参
int arr[10] = {0};
可以用int arr[]和int arr[10]和int *arr接收。
int *arr[10] = {0};
这里的arr可以用int *arr[10] 和int **arr接收。
2.2二维数组传参
int arr[3][5] = {0};
这里的arr可以用int arr[3][5]和int arr[][5]和int (*arr)[5]接收，其他的都不行。
2.3一级指针传参
void test(int *p){}
这里的int *p可以用&变量和数组名和指针传参。
2.4二级指针传参
void test(int **ptr){}
这里的int **ptr可以用二级指针和&一级指针和指针数组传参。
3.函数指针
这里的函数名就是函数的地址。这里用这个Add来写一下函数指针，void (*padd)(int x,int y);这个就是函数指针，首先把padd和void ( * )(int x,int y)分开，首先是一个指针，这个指针的类型是函数，指向函数，这个函数的参数是x和y，返回值是void。
上述代码改进：
int Add(int x, int y) { return x + y; } int main() { int a = 10; int b = 20; int (*padd)(int x,int y) = &Add; int ret = padd(3,5); printf("%d\n", ret); return 0; } //结果是8- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
下面来看看这个代码是什么意思？
(* ( void( * )( ) )0 )( );
解释：void( * )( )是函数指针类型，把0强制类型转换为函数指针类型，调用0地址处的函数。这里这个代码也可以写成( void( * )( ) )0 ( );
void (* signal(int ,void( * )(int) )(int);
解释：上述代码是函数声明，声明的函数叫做signal，函数的第一个参数是int类型，第二个参数是函数指针类型，该函数指针指向的函数参数是int,返回类型是void，signal函数的返回类型也是一个函数指针，该函数指针指向的函数参数是int,返回类型是void。4. 函数指针数组
比如：int (*p[3])(int x,int y);这里p是指数组，p中存放的是函数指针。
使用场景（模拟计算器）：
#includeint 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; //函数指针数组 int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; while (input) { printf("*************************\n"); printf(" 1:add 2:sub \n"); printf(" 3:mul 4:div \n"); printf("*************************\n"); printf("请选择："); scanf("%d", &input); if ((input <= 4 && input >= 1)) { printf("输入操作数："); scanf("%d %d", &x, &y); ret = (*p[input])(x, y); //ret = p[input](x,y); } else printf("输入有误\n"); printf("ret = %d\n", ret); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
5. 指向函数指针数组的指针
函数指针数组：int (*p[3])(int x,int y);
指向函数指针数组的指针：int ( * (*p)[3])(int x,int y);6. 回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的用于对该事件或条件进行响应。
上述模拟计算器可以这样来写（利用回调函数）：
#includeint 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 (*p)(int, int)) { int x = 0; int y = 0; int ret = 0; printf("请输入2个操作数:>"); scanf("%d %d", &x, &y); //回调函数 ret = p(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); } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
6.1.qsort库函数
初步了解：
再次理解：
qsort库函数可以对任意类型数据进行排序，其原理类似于快速排序。
base：待排序数组的起始地址
num:待排序数据的元素个数
size:待排序数组的元素的大小
int (* compare)(const void*,const void*): 比较两个元素的大小的函数指针6.1.1 qsort库函数排序整型数组
int compare(const void* a, const void* b) { return *(int*)a - *(int*)b; } void print(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } } int main() { int arr[5] = { 2,3,4,1,5 }; int sz = sizeof(arr) / sizeof(arr[0]); qsort(arr, sz, sizeof(int), compare); print(arr, sz); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
6.1.2 qsort库函数排序结构体数据
6.1.2.1 按照名字大小来排序
struct stu { char name[20]; int age; }; int cmp_by_name(const void* a, const void* b) { return strcmp(((struct stu*)a)->name, ((struct stu*)b)->name); } void print(struct stu s[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%s\n", s[i].name); } } int main() { struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} }; int sz = sizeof(s) / sizeof(s[0]); //按照名字比较 qsort(s, sz, sizeof(s[0]), cmp_by_name); print(s, sz); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
6.1.2.2 按照年龄来排序
struct stu { char name[20]; int age; }; int cmp_by_age(const void* a, const void* b) { return (((struct stu*)a)->age - ((struct stu*)b)->age); } void print(struct stu s[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d\n", s[i].age); } } int main() { struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} }; int sz = sizeof(s) / sizeof(s[0]); //按照年龄比较 qsort(s, sz, sizeof(s[0]), cmp_by_age); print(s, sz); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
6.2 实现冒泡排序对任意类型的排序
6.2.1 对整型排序
int cmp_int(const void* e1, const void* e2) { return (*(int*)e1 - *(int*)e2); } void Swap(char* buf1, char* buf2, int size) { int i = 0; for (i = 0; i < size; i++) { char tmp = *buf1; *buf1 = *buf2; *buf2 = tmp; buf1++; buf2++; } } void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a,const void* b)) { int i = 0; for (i = 0; i < sz - 1; i++) { int j = 0; for (j = 0; j < sz - 1 - i; j++) { 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(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } } int main() { int arr[] = { 2,1,3,7,5,9,6,8,0,4 }; int sz = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr, sz, sizeof(arr[0]),cmp_int); print(arr, sz); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
6.2.2 对结构体排序
6.2.2.1 按照年龄进行排序
struct stu { char name[20]; int age; }; int cmp_by_age(const void* a, const void* b) { return (((struct stu*)a)->age - ((struct stu*)b)->age); } void Swap(char* buf1, char* buf2, int size) { int i = 0; for (i = 0; i < size; i++) { char tmp = *buf1; *buf1 = *buf2; *buf2 = tmp; buf1++; buf2++; } } void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a, const void* b)) { int i = 0; for (i = 0; i < sz - 1; i++) { int j = 0; for (j = 0; j < sz - 1 - i; j++) { 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(struct stu s[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", s[i].age); } } int main() { struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} }; int sz = sizeof(s) / sizeof(s[0]); //按照年龄比较 qsort(s, sz, sizeof(s[0]), cmp_by_age); print(s, sz); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
6.2.2.2 按照名字排序
struct stu { char name[20]; int age; }; int cmp_by_name(const void* a, const void* b) { return strcmp(((struct stu*)a)->name, ((struct stu*)b)->name); } void Swap(char* buf1, char* buf2, int size) { int i = 0; for (i = 0; i < size; i++) { char tmp = *buf1; *buf1 = *buf2; *buf2 = tmp; buf1++; buf2++; } } void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a, const void* b)) { int i = 0; for (i = 0; i < sz - 1; i++) { int j = 0; for (j = 0; j < sz - 1 - i; j++) { 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(struct stu s[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%s ", s[i].name); } } int main() { struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} }; int sz = sizeof(s) / sizeof(s[0]); //按照年龄比较 qsort(s, sz, sizeof(s[0]), cmp_by_name); print(s, sz); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
-
相关阅读:
笔记-Python lambda
.NET 反向代理-YARP 根据域名转发
USB 四种传输方式的通信API
【简单讲解Perl语言】
kettle通过java步骤获取汉字首拼
300万赛事门票上链，杭州亚运会打造史上首个“链上亚运”
越小越好: Q8-Chat，在英特尔至强 CPU 上体验高效的生成式 AI
Re29：读论文 D2GCLF: Document-to-Graph Classifier for Legal Document Classification
element表格分页+数据过滤筛选
岩藻多糖-聚乙二醇-过氧化氢酶，Catalase-PEG-Fucoidan，过氧化氢酶-PEG-岩藻多糖
- 原文地址：https://blog.csdn.net/m0_46343224/article/details/126630269
