㊙️小明博客主页：➡️ 敲键盘的小明 ㊙️
✅关注小明了解更多知识☝️
文章目录
前言
提示：本篇文章为C语言指针进阶的详细笔记和完整的源码，内容如若有误，请联系小明及时更正。
- 转载请注明原创，谢谢。
提示：以下是本篇文章正文内容：
前情回顾：
- 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
- 指针的大小是固定的4/8个字节（32位平台/64位平台）。
- 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
- 指针的运算。
本篇所讲的是指针的进阶内容，虽然小明在之前的【C语言指针】中我们了解了什么是指针、指针和指针类型的区别、野指针、指针运算、指针和数组、二级指针以及指针数组，但其内容仅是指针的一些基础，那么本篇博客我们就来记录一下进阶版的指针究竟是怎样的：
一、字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char * ;
让我们先来看一段代码：
#include<stdio.h>
int main()
{
char ch = 'M';
char* p = &ch;
printf("%c\n", *p);
return 0;
}
代码运行截图：
然后呢，我们再将代码改动一下：
int main()
{
const char* p = "Xiao Ming";
printf("%s\n", p);
printf("%c\n", *p);
return 0;
}
代码运行截图：
从上面的代码我们可以看到，给出指针首地址，打印的是整个字符串；指针解引用，打印1个字符。
- 接下来我们再看一个面试题的代码：
#include <stdio.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");
}
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 main()
{
char* str[20]; //一级字符指针数组
int* arr[10]; //一级整型指针数组
int** arr1[5]; //二级整型指针数组
return 0;
}
我们用指针数组模拟一个二维数组：
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
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("\n");
}
return 0;
}
代码运行结果：
指针数组存放多个字符串：
#include <stdio.h>
int main()
{
char* arr[5] = { "hello world","China","C","C++","XiaoMing" };
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%s\n", arr[i]);
}
return 0;
}
代码运行结果：
三、数组指针
3.1 数组指针的定义
数组指针是指针？还是数组？
答案是：指针。
字符指针 ↔️ 存放字符地址的指针 ↔️ 指向字符的指针 类型：char*
整型指针 ↔️ 存放整型地址的指针 ↔️ 指向整型的指针 类型：int*
浮点型指针 ↔️ 存放浮点型的指针 ↔️ 指向浮点型的指针 类型：float* double*
数组指针 ↔️ 存放数组地址的指针 ↔️ 指向数组的指针
int (*p)[10];
解释：
p先和 * 结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以 p是一个指针，指向一个数组，叫数组指针。
这里要注意：[ ]的优先级要高于 * 号的，所以必须加上（）来保证 p 先和 * 结合。
3.2 数组名 和 &数组名
对于下面的数组：
int arr[10];
arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那么 &arr 数组名到底是啥？
我们看一段代码：
#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 。
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;
}
一个数组指针的使用：
void print(int arr[3][5], int r, int c)
{
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { {1,2,3,4,5},{5,6,7,8,9},{1,3,5,7,9} };
print(arr, 3, 5);
return 0;
}
代码运行结果：
✅学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];
四、数组参数、指针参数
4.1 —维数组传参
#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr)//ok?
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
}
4.2 二维数组传参
void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int(*arr)[5])//ok？
{}
void test(int** arr)//ok？
{}
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;
}
代码运行结果：
❓ 当一个函数的参数部分为一级指针的时候，函数能接受什么参数？
#include <stdio.h>
void test(int* p)
{
}
int main()
{
int a = 0;
int* ptr = &a;
int arr[5];
test(arr);//传整型一维数组的数组名
test(&a);//传整型变量的地址
test(ptr);//传整型指针
return 0;
}
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;
}
代码运行结果：
❓当函数的参数为二级指针的时候，可以接收什么参数？
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;
}
五、函数指针
&函数名就是函数的地址
函数名也是函数的地址
void test()
{
printf("Xiaoming\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
函数指针该怎么做呢：
int Add(int x, int y)
{
return x + y;
}
int main()
{
int x = 3;
int y = 5;
int(*pf)(int, int) = &Add;
printf("%d", (*pf)(x, y));
return 0;
}
这里的int (*pf)(int, int) = &Add;与上面的数组指针类似，其实它就是函数指针！*先与pf结合说明是指针，指向的对象是后面的函数，指向函数的有两个参数都是int类型，函数的返回值是int
两个有趣的代码
两个代码出自于《C的陷阱和缺陷》
代码1：
解释：
代码2：
解释：
六、函数指针数组
6.1 函数指针数组的概念
int* arr[10]; 这样的数组是指针数组，里面的每个元素的类型是 int* 的指针！函数指针也是指针，应该也能存放到数组中，其实这样的数组就叫函数指针数组！那么如何定义呢？
void test()
{
}
int main()
{
int(*p)(int, int) = test;
return 0;
}
这是个函数指针的定义，在函数指针的定义上进行修改，就可以得到函数指针数组！如下：
int main()
{
int(*p[10])(int, int);
return 0;
}
6.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");
}
int main()
{
int x = 0;
int y = 0;
int input = 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 + %d = %d\n", x, y,ret);
break;
case 2:
printf("请输入操作数: ");
scanf("%d %d", &x, &y);
ret = sub(x, y);
printf("%d - %d = %d\n", x, y, ret);
break;
case 3:
printf("请输入操作数: ");
scanf("%d %d", &x, &y);
ret = mul(x, y);
printf("%d * %d = %d\n", x, y, ret);
break;
case 4:
printf("请输入操作数: ");
scanf("%d %d", &x, &y);
ret = div(x, y);
printf("%d / %d = %d\n", x, y, ret);
break;
case 0:
printf("退出成功!\n");
break;
default:
printf("选择的数字错了!重新选择!\n");
}
} while (input);
return 0;
}
代码运行结果：
虽然顺利实现了计算器，但是我们可以发现，这段代码中，输入 x 和 y 时的代码、输出结果时的代码是重复出现的，那么我们又该如何避免这种过于冗余的代码呢？
我们用函数指针数组来简化一下计算器冗余的部分：
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 main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
int (*pfArr[])(int, int) = { NULL, Add, Sub, Mul, Div };
// 0 1 2 3 4
// 加一个空指针 NULL 可以更顺滑的选择功能
if (0 == input)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入2个操作数:");
scanf("%d %d", &x, &y);
ret = pfArr[input](x, y);
printf("ret = %d\n", ret);
}
else
{
printf("选择的数字错了!重新选择!\n");
}
} while (input);
return 0;
}
代码运行结果：
七、指向函数指针数组的指针
【 了解即可 】
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针
void (*pf)(const char*) = test;
//函数指针数组
void (*pfarr[10])(const char*) = { pf };
//指向函数指针数组的指针
void (*(*pf_p)[10])(const char*) = &pfarr;
return 0;
}
八、回调函数
8.1 什么是回调函数
回调函数就是一个通过函数指针调用的函数。
如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
回调函数的优点：
- 提高代码的模块化程度：回调函数允许我们将函数作为参数传递给其他函数，使得函数之间的耦合度降低，提高了代码的模块化程度。
- 提高代码的可扩展性：通过使用回调函数，我们可以轻松地更改或扩展函数的行为，而无需修改原始函数的代码。
- 提高代码的可维护性：回调函数使得代码更加灵活，可以更容易地进行修改和调试。
使用回调函数优化计算器代码：
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;
}
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("ret = %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;
}
小明来帮助大家理解一下回调函数：
8.2 回调函数的演示（用qsort）:
例子：使用回调函数，模拟实现qsort（采用冒泡的方式）。
void print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
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]);
print_arr(arr, sz);
bubble_sort(arr, sz);//冒泡排序
print_arr(arr, sz);
return 0;
}
代码运行结果：
但是，这样的回调函数只能排序整型数据，那要是我们不只是排序整型数据呢？又该如何？
qsort（Quick Sort）是一种基于比较的排序算法，它采用分治策略对输入数组进行排序。
qsort 函数是 C 语言标准库中提供的用于对数组进行排序的函数。它接受一个指向数组的指针、数组的长度和一个比较函数作为参数。比较函数用于比较两个元素的大小，以确定它们的顺序。
标签：arr,进阶,int,void,C语言,数组,printf,指针 From： https://blog.csdn.net/mingloveyang/article/details/139465161