✨博客主页:心辛向荣
✨系列专栏:【从0到1，C语言学习】
✨一句短话:你若盛开，蝴蝶自来！
✨博客说明:尽己所能，把每一篇博客写好，帮助自己熟悉所学知识，也希望自己的这些内容可以帮助到一些在学习路上的伙伴，文章中如果发现错误及不足之处，还望在评论区留言，我们一起交流进步！😊
前言
🍁这篇博客介绍指针部分的内容，不过不会在指针的基础知识上介绍太多，本篇属于指针部分的进阶，在基础之上深入理解！
关于这部分更为基础的知识可以看我的另一篇博客 指针初阶 。
一. 字符指针
1. 理解用法
- 关于字符指针char* ,常见的一种用法如下：
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'w';
return 0;
}
- 这里重点理解下面这种使用方式：
int main()
{
const char* p = "abcdef";
//把字符串首字符a的地址，赋值给了p
printf("%s\n", p);
return 0;
}
对于这里的理解，千万不能理解为是把一个字符串放到p指针变量里；这个代码真正的作用是把字符串首字符a的地址，赋值给了p，只要给出字符串的起始地址p，便可以打印字符串！
这里要注意常量字符串“abcdef”是存放在只读数据区当中的，可以读取，但不能被更改，所以使用const修饰防止通过 *p 修改字符串，关注这些细节以增强代码的健壮性。
2. 一道面试题
#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char* str3 = "hello bit.";
const char* str4 = "hello bit.";
if (str1 == str2)
printf("str1 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相同。
二. 指针数组
指针数组是组是一个存放指针的数组，在另一篇基础博客中有详细介绍。
int* arr1[10]; //整形指针的数组
char* arr2[4]; //一级字符指针的数组
char** arr3[5];//二级字符指针的数组
三. 数组指针
1. 定义：
数组指针是能够指向数组的指针。
int (*p)[10]；
对于数组指针形式的理解：
p先和*结合，说明p是一个指针变量，然后先后看指针指向的是一个大小为10个整型的数组，数组中每个元素的元素类型为int；所以p是一个 指针，指向一个数组，叫数组指针。
这里要注意：[ ]的优先级要高于 * 号的，所以必须加上（）来保证p先和*结合。
2. 数组指针的使用
那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
要想对这部分码有清晰的理解，需要对数组名有一定的理解，在数组对应的博客中有介绍对于数组名的理解，关于数组名 。
- 看下面这段代码，理解数组指针，但在 实际写代码中很少写这样的代码！
int main()
{
int arr[] = {
1,2,3,4,5,6,7,8,9,10 };
int (*p)[10] = &arr;
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
printf("%d ", *(*p+i));
//p是指向数组的，
// *p其实就相当于数组名,数组名又是数组首元素的地址
//所以*p本质上是数组首元素的地址
}
return 0;
}
p 是指向数组的，p解引用找到数组对应的内存空间，也就是找到数组的起始地址，而数组名是数组首元素的地址，所以p本质上是数组首元素的地址！
- 数组指针的使用一般应用在二维/三维。。。数组的使用上:
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++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
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]);//等价
}
printf("\n");
}
}
int main()
{
int arr[3][5] = {
1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
//形参是数组形式
print1(arr, 3, 5);
//形参是指针形式
print2(arr, 3, 5);
return 0;
}
数组名arr，表示首元素的地址，但是二维数组的首元素是二维数组的第一行，所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址， 可以数组指针来接收。
3. 熟悉巩固
int arr[5];
//整形数组
int *parr1[10];
//整形指针数组
int (*parr2)[10];
//数组指针
int (*parr3[10])[5];
//存放数组指针的数组
//类型：int (*) [5]
四. 数组参数、指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢；下面的传参有错误的也有正确的，帮助熟悉理解指针的正确运用。
1. 一维数组传参
#include <stdio.h>
void test(int arr[])//正确
{
}
void test(int arr[10])//正确
{
}
void test(int* arr)//正确
{
}
void test2(int* arr[20])//正确
{
}
void test2(int** arr)//正确
{
}
int main()
{
int arr[10] = {
0 };
int* arr2[20] = {
0 };
test(arr);
test2(arr2);
return 0;
}
2. 二维数组传参
void test(int arr[3][5])//正确
{
}
void test(int arr[][])//错误
{
}
void test(int arr[][5])//正确
{
}
void test(int* arr)//错误
{
}
void test(int* arr[5])//错误
{
}
void test(int(*arr)[5])//正确
{
}
void test(int** arr)//错误
{
}
int main()
{
int arr[3][5] = {
0 };
test(arr);
return 0;
}
总结：二维数组传参，函数形参的设计只能省略第一个[]的数字；因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素；这样才方便运算。
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 print(int* p)
{
}
//test1函数能接收什么参数？
int main()
{
int a = 10;
int* ptr = &a;
int arr[10];
print(&a);
printf(ptr);
printf(arr);
return 0;
}
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)
//test函数能接收什么参数？
{
}
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char*** pppc = &ppc;//三级指针
char* arr[10];//指针数组
test(&pc);
test(ppc);
test(arr);
test(*pppc);//三级指针一次解引用
return 0;
}
五. 函数指针
首先观察一段代码：
输出的是两个地址，对于函数来说，&函数名和函数名都是函数的地址！
函数指针的使用：
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = Add;//函数指针
int ret = (*pf)(2, 3);
int ret = Add(2, 3);
int ret = pf(2, 3);
//这三种写法一样的效果。
printf("%d\n", ret);
return 0;
}
对于代码中函数指针形式的理解：
pf用来存放函数指针，pf先和*结合，说明pfun1是指针，然后向后看指针指向的是一个函数，指向的函数为俩个整形，返回值类型为int。
看下面俩个代码，取自《C陷阱与缺陷》！
//代码1
(* ( void (*)() )0 )();
//代码2
void(* signal(int, void(*)(int)) )(int);
代码1解析：
这个代码是一次函数调用，调用的是0作为地址处的函数；
- ( void (*)() )0把0强制类型转换为：无参，返回类型是void的函数的地址
- 调用0地址处这个函数
代码2解析：
signal是函数名，此代码是一次函数声明;
声明的signal函数的第一个参数的类型是int，第二个参数的类型是函数指针，该函数指针指向的参数是int，返回类型是void，signal函数的返回类型也是一个函数指针void(*)(int)，该函数指针指向的参数是int，返回类型是void。
将代码2写为更好理解的方式：
typedef void(*pf_t)(int);
//对void(*)(int)进行类型重命名pf_t
pf_t signal(int, pf_t);
//与代码2等价
函数指针的实际运用在回调函数，在后面会介绍到！
六. 函数指针数组
定义： 把函数的地址存到一个数组中，那这个数组就叫函数指针数组 ！
int (*parr1[10])();
//parr1先和[]结合，说明parr1是数组，
//数组中的元素是int(*)()类型的函数指针
函数指针数组的用途：转移表
示例:
实现一个有加减乘除功能的计算器(只针对整形).
一般实现方式：
#include <stdio.h>
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 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
{
menu();
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");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}
使用函数指针数组实现：
减少了代码的冗余，代码更加简洁，
#include <stdio.h>
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 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()
{
menu();
int x, y;
int input = 1;
int ret = 0;
int(*p[5])(int x, int y) = {
0, add, sub, mul, div }; //转移表
while (input)
{
menu();
printf("请选择：");
scanf("%d", &input);
if ((input <= 4 && input >= 1))
{
printf("输入操作数：");
scanf("%d %d", &x, &y);
ret = (*p[input])(x, y);
}
else
printf("输入有误\n");
printf("ret = %d\n", ret);
}
return 0;
}
七. 指向函数指针数组的指针
指向函数指针数组的指针是一个指针；
指针指向的是一个数组，数组的元素是函数指针。
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;
}
八. 回调函数
定义： 回调函数就是一个通过函数指针调用的函数；如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
函数指针的运用实例子:
将上面的计算器代码以回调函数的方式实现，
#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;
}
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;
}
库函数qsort
这里介绍库函数qsort，qsort是一种基于快速排序思想的一个排序函数，qsort函数的实现就运用了回调函数！
qsort可以排序任意类型的数据，而比较函数需要我们自行设计，其俩个参数的类型为空指针类型void * *,*可以接受任意类型的地址，这里要注意的是void * 是无具体类型的指针，所以不能直接进行解引用使用的，也不能进行 ±整数的运算，在执行比较的过程中要对其进行对应类型的强制类型转换！
qsort默认是进行升序排序的，如果想要排成降序，只需要将比较函数中的两个参数调换位置即可！
- 使用库函数，qsort排序各种类型的数据:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{
char name[10];
int age;
};
int cmp_int(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
void test1()
{
int arr[10] = {
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]);
}
printf("\n");
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test2()
{
struct Stu s[] = {
{
"zhang", 19 }, {
"li ", 20 }, {
"wang", 21}};
int sz = sizeof(s) / sizeof(s[0]);
qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%-5s %-5d", s[i].name, s[i].age);
printf("\n");
}
}
int cmp_stu_by_age(const void* e1, const void* e2)
{
return ((struct Stu*)e2)->age - ((struct Stu*)e1)->age;
}
void test3()
{
struct Stu s[] = {
{
"zhang", 19 }, {
"li ", 20 }, {
"wang", 21} };
int sz = sizeof(s) / sizeof(s[0]);
qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%-5s %-5d", s[i].name, s[i].age);
printf("\n");
}
}
int cmp_char(const void* e1, const void* e2)
{
return *(char*)e2 - *(char*)e1;
}
test4()
{
char ch[6] = {
'a', 'b', 'c', 'd', 'e', 'f' };
int sz = sizeof(ch) / sizeof(ch[0]);
qsort(ch, sz, sizeof(ch[0]), cmp_char);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%c ", ch[i]);
}
printf("\n");
}
int main()
{
//测试排序整形数据
test1();
printf("\n");
//测试成员name(字符串)排序结构体
test2();
printf("\n");
//测试通过成员age(整型)排序结构体
test3();
printf("\n");
//测试排序字符数据
test4();
return 0;
}
运行结果:
- 使用回调函数，模拟实现qsort（采用冒泡排序的方式）。
#include<stdio.h>
#include<string.h>
struct Stu
{
char name[10];
int age;
};
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++;
}
}
void bubble_sort(void* base, int sz, int width, int(*cmp)(const void*e1, const void* e2))
{
int i = 0;
int flag = 1;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
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;
}
}
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int main()
{
struct Stu s[] = {
{
"zhang", 19 }, {
"li ", 20 }, {
"wang", 21}};
int sz = sizeof(s) / sizeof(s[0]);
bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%-5s %-5d", s[i].name, s[i].age);
printf("\n");
}
return 0;
}
运行结果:
结语
各位小伙伴，看到这里就是缘分嘛，希望我的这些内容可以给你带来那么一丝丝帮助，可以的话三连支持一下呗😁！！！ 感谢每一位走到这里的小伙伴，我们可以一起学习交流，一起进步😉！！！加油🏃！！！
转载：https://blog.csdn.net/Trong_/article/details/125527217
查看评论