文章目录
指针的进阶
一、字符指针
（Ⅰ）定义字符指针
-
char *p;代码声明了一个名为
p的指针变量，它可以指向一个char类型的数据。
（Ⅱ）初始化字符指针
-
可以将字符指针初始化为指向一个字符串字面量，或者指向一个字符数组：
char *p = "Hello"; char arr[] = {'H', 'e', 'l', 'l', 'o'}; char *p = arr;char *p = "Hello";*p指向字符串的首地址（字符H的地址）
char *p = arr;*p指向arr数组首元素的地址（即元素H的地址）
在C语言中，字符串通常以空字符\0结尾，这允许使用字符串处理函数（如strlen、strcpy等）来操作字符串。当你将一个字符串字面量赋值给一个字符指针时，编译器会自动在字符串的末尾添加空字符。
举例：
int main() { char arr1[] = "abcde"; char arr2[] = "abcde"; char* p1 = "abcde"; char* p2 = "abcde"; if (arr1 == arr2) printf("arr1 = arr2\n"); else printf("arr1 != arr2\n"); if (p1 == p2) printf("p1 = p2\n"); else printf("p1 != p2\n"); return 0; }
结果：
arr1 != arr2 p1 = p2
arr1和arr2是两个字符数组，它们分别被初始化为字符串"abcde"。在C语言中，字符数组是存储在内存中的具体区域，每个数组都有自己的内存空间。因此，即使arr1和arr2被初始化为相同的字符串，它们在内存中的地址也是不同的。
p1和p2是两个字符指针，它们都被初始化为指向同一个字符串字面量"abcde"。在C语言中，字符串字面量通常存储在程序的只读数据段中，并且所有指向同一个字符串字面量的指针都将共享这个相同的地址。
二、指针数组
（Ⅰ）指针数组的定义
指针数组： 是指用来存放指针的数组
int arr[5];//整型数组
char ch[3];//字符数组
//指针数组
int* arrp[5];//存放整型指针的数组
char* chp[3];//存放字符指针的数组
举例：
int main(){ int arr1[] = { 1,2,3,4 }; int arr2[] = { 2,3,4,5 }; int arr3[] = { 3,4,5,6 }; //创建指针数组存放三个整型数组的首地址（模拟二维数组） int* parr[3] = { arr1,arr2,arr3 }; return 0; }
三、数组指针
（Ⅰ）数组指针的定义
数组指针： 指向数组的指针
- 数组指针通常用于函数参数，允许函数直接修改传入的数组内容，或者用于创建动态分配的多维数组。
定义数组指针：
类型 (*指针名)[数组大小];
指针数组与数组指针
1️⃣ 指针数组
类型 *指针数组名[数组大小]; int *p1[10]; // 指针数组，包含10个指向int的指针
p1是指针数组，数组中的每个元素都是指向int（整数）的指针
2️⃣ 数组指针
类型 (*指针名)[数组大小]; int (*p2)[5];
p2是数组指针，p2可以指向一个大小为5个整型的数组
（Ⅱ）数组名与&数组名
int main() {
int arr[10];
printf("%p\n", arr); //010FF73C
printf("%p\n", &arr[0]);//010FF73C
printf("%p\n", &arr); //010FF73C
printf("\n");
printf("%d\n", sizeof(arr));//40
return 0;
}
数组名通常表示的都是数组首元素的地址，但有两个例外：
sizeof(数组名)，这里的数组名表示的是整个数组，计算的是整个数组的大小&数组名，这里的数组名依然表示的是整个数组，所以&数组名取出的是整个数组的地址
int main() {
int arr[10];
printf("%p\n", arr); //001AFA90
printf("%p\n", arr+1);//001AFA94-相差4字节
printf("\n");
printf("%p\n", &arr[0]); //001AFA90
printf("%p\n", &arr[0]+1);//001AFA94-相差4字节
printf("\n");
printf("%p\n", &arr); //001AFA90
printf("%p\n", &arr+1);//001AFAB8-相差40字节
printf("\n");
return 0;
}
- 可见
&arr取出的是整个数组的地址，也因此&arr+1与&arr之间相差 4 ∗ 10 = 40 4*10=40 4∗10=40个字节 int* p = arr可以使用整型指针p来存放arrint (*p2)[10] = &arr使用p2来存放&arr
利用数组指针p2存放&arr：
int (*p2)[10] = &arr
- 数组指针名：
p2- 数组指针类型：
int (*)[10]
- 数组指针
p2指向的是包含5个int类型元素的数组p2 + 1将跳过整个数组（跳过40个字节）- 元素个数：
10- 存放的数组地址：
&arr
（Ⅲ）数组指针的应用
- 数组指针在一维数组中并不常用
int main() { int arr[5] = { 1,2,3,4,5 }; int (*parr)[5] = &arr;//把数组arr[5]的地址赋给数组指针变量parr int i = 0; for (i = 0; i < 5; i++) { printf("%d ", *(*parr + i));//printf("%d ", (*parr)[i]); } return 0; }
- 这段代码的作用是通过数组指针
parr来遍历数组arr的元素parr是一个指向数组的指针，所以*parr解引用这个指针，得到arr数组（即arr数组的首地址）*parr + i是数组加上索引i的地址（类似arr + i）*(*parr + i)==(*parr)[i]是对上述地址进行解引用，得到数组的第i个元素（即*(arr + i)）
- 二维数组的数组名代表的是指向该数组首元素的指针。对于一个二维数组来说，这个
“首元素”实际上是一个一维数组。因此，当有一个二维数组arr[][]时，arr的值是一个指向第一个一维数组的数组指针
void print1(int (*parr)[4], int row, int col) {
//使用数组指针来接收数组名arr（即第0行的一个一维数组的地址）
int i = 0;
for (i = 0; i < row; i++) {
int j = 0;
for (j = 0; j < col; j++) {
printf("%d ", *(*(parr + i) + j));
//printf("%d ", parr[i][j]);
}
printf("\n");
}
}
int main() {
int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
print1(arr, 3, 4);
return 0;
}
-
1 2 3 4 2 3 4 5 3 4 5 6
parr是数组指针，指向整个一维数组（这里指向第0行，元素为1，2，3，4的一维数组）
parr + 1即可跳过整个一维数组，指向下一个一维数组*(parr + 1)对数组指针解引用，指向该一维数组的第一个元素，相当于一维数组数组名的作用*(parr + 1) + 1指向该一维数组的下一个元素，对此再次解引用即可得到该元素【 ∗ ( ∗ ( p a r r + 1 ) + 1 ) = 3 *(*(parr + 1) + 1)= 3 ∗(∗(parr+1)+1)=3】- 注意： 这里==( )==的位置非常重要！
*(p+i)等价于p[i]，因此*(*(parr + i) + j)可以写成parr[i][j]
int arr[5];arr是整型数组
int *parr1[10];parr1是指针数组
int (*parr2)[10];parr2是数组指针
int (*parr3[5])[10];parr3是存放数组指针的数组
四、数组参数与指针参数
（Ⅰ）一维数组的传参
void Test_1(int arr[]) {
//创建数组来接收传递过来的arr_1
}
void Test_1(int arr[10]) {
//[]中的值不影响
}
void Test_1(int* parr) {
//创建指针变量parr来接收数组首元素的地址
}
int main() {
int arr_1[10];//arr_1中存放10个整型数据
Test_1(arr_1);//传递首元素的地址
return 0;
}
void Test_2(int* arr[5]) {
//创建指针数组arr来接收arr_2
}
void Test_2(int** pparr) {
//创建二级指针pparr来接收地址的地址
}
int main() {
int* arr_2[5];//arr_2中存放5个地址（指针）
Test_2(arr_2);//传递首元素的地址（即地址的地址）
return 0;
}
- 在指针数组中，首元素是一个指针类型（即一个地址），在使用数组名传参时传递的是该地址的地址，因此外部函数在接收参数时要使用二级指针
（Ⅱ）二维数组的传参
void Test(int arr[3][4]) {
//创建一个相同大小的二维数组来接收形参
}
void Test(int arr[ ][4]) {
//二维数组传参，形参只能省略行的地址，不能省略列的地址
}
void Test(int (*parr)[4]) {
//使用数组指针来接收arr（一维数组的地址）
}
int main() {
int arr[3][4];//3行4列的二维数组
Test(arr);//二维数组的数组名表示首元素的地址是第一行（一个一维数组）的地址
return 0;
}
- 二维数组传参，形参只能省略行的地址，不能省略列的地址
- 二维数组的数组名，表示首元素的地址是第一行（一整个一维数组）的地址
（Ⅲ）一级指针的传参
#include <stdio.h>
// 函数声明，接受一个一级指针作为参数
void Test(int *ptr) {
// 递增指针指向的值
*ptr += 1;
}
int main() {
int a = 10;
int* p = &a;
int arr[3];
// 传递变量的地址给函数
Test(&a);
Test(p);
Test(arr);
return 0;
}
-
对于函数
void Test(int *ptr);，接收的数据得是int* （int 类型的地址）类型- 例如：
Test(&a); Test(p); Test(arr);
- 例如：
（Ⅳ）二级指针的传参
- 二级指针传参则使用二级指针接收
void Test(int** pp) {
//二级指针传参则使用二级指针接收
}
int main() {
int a = 10;
int* p = &a;
int** p2 = &p;
Test(p2);
return 0;
}
- 形参为二级指针，则可传递的实参
void Test(int** pp) {
//二级指针传参则使用二级指针接收
}
int main() {
int a = 10;
int* p = &a;
int** p2 = &p;
Test(p2);//二级指针
Test(&p);//一级指针取地址
Test(arr);//指针数组数组名
Test(*p3);//三级指针解引用
return 0;
}
可传递的参数：
Test(p2);二级指针Test(&p);一级指针取地址Test(arr);指针数组数组名Test(*p3);三级指针解引用
五、函数指针
（Ⅰ）定义函数指针
数组指针 - 指向数组的指针
返回类型 (*指针名)[数组大小];函数指针 - 指向函数的指针
返回类型 (*函数指针名)(参数类型1, 参数类型2, ...);
- 假设函数
Add()有一个返回int类型，且接收两个int类型参数，则可以定义一个指向这种函数的指针如下：- eg:
int (*pf)(int, int) = &Add
int Add(int a, int b) {
return a + b;
}
int main() {
printf("%p\n", &Add);
printf("%p\n", Add);
return 0;
}
-
00BB13D9 00BB13D9 -
可见函数也是有地址的，且
&函数名与函数名都是函数的地址
函数指针是指向函数的指针，它允许你将函数作为参数传递给其他函数，或者将函数赋值给变量。在C语言中，函数指针的使用可以提高程序的灵活性和模块化。
（Ⅱ）初始化函数指针
函数指针可以被初始化为指向特定的函数，例如：
int Add(int a, int b) {
return a + b;
}
int main() {
int (*pf)(int, int) = Add;//创建一个函数指针存放函数Add()的地址
//int (*pf)(int, int) = &Add;
return 0;
}
（Ⅲ）使用函数指针
使用函数指针调用函数时，需要使用括号来解引用指针，如下所示：
int Add(int a, int b) {//此时a=5,b=3
return a + b;//返回5+3=8
}
int main() {
int (*pf)(int, int) = Add;//*pf的*号可以省略
//int pf(int, int) = Add;
int ret = (*pf)(5, 3); // 调用 Add 函数，等同于 Add(5, 3)
//此处的*也可以省略
return 0;
}
（Ⅳ）函数指针作为参数
函数指针经常作为参数传递给其他函数，这允许函数根据传入的函数指针来执行不同的操作。例如，编写一个函数，它接受一个函数指针作为参数，并使用这个指针来调用函数：
#include <stdio.h>
// 一个简单的函数，返回两个整数的和
int add(int a, int b) {
return a + b;
}
// 另一个函数，返回两个整数的差
int sub(int a, int b) {
return a - b;
}
// 接受函数指针作为参数的函数
void AF(int (*func)(int, int), int a, int b) {
printf("结果: %d\n", func(a, b));
}
int main() {
AF(add, 10, 5); // 输出：结果: 15
AF(sub, 10, 5); // 输出：结果: 5
return 0;
}
在这个例子中，AF 函数接受一个函数指针 func 作为参数，并使用它来计算 a 和 b 的结果。
(*(void(*)())0)();
此例出自：《C陷阱与缺陷》
int main() {
(*( void(*)() )0 ) ();
return 0;
}
void(*p)()p是函数指针故
void(*)()是函数指针类型，类似于int* char*等
( void(*)() )0=(函数指针类型)0即：将0强制转换为函数指针类型 （强制类型转换）
- 把0强制转换为：无参数，返回类型为void的函数的地址
(*( void(*)() )0 ) ();=( *(地址0) )()调用0地址处的函数，（类似使用函数指针：(*pf)(int, int)）
void (*signal(int, void(*)(int)))(int);
int main() {
void (*signal(int, void(*)(int)))(int);
return 0;
}
void (*signal(int, void(*)(int)))(int);这是一个函数声明
int Add(int a, int b) {//创建一个函数 } int Add(int, int);//对Add()函数声明（返回类型+函数名+参数类型）
void(*)(int)是函数指针类型
signal(int, void(*)(int))是对signal()函数的声明，但缺少返回类型
void (*_______)(int);可见返回类型是函数指针类型
-
为了简化返回类型为函数指针类型的函数的声明，可以使用
typedef关键字来重定义函数指针类型的名称 -
typedef void(*pf_t)(int);//把void(*)(int)类型重命名为pf_t int main() { void (*signal(int, void(*)(int)))(int); pf_t signal(int, pf_t); return 0; } -
typedef void(*pf_t)(int);把void(*)(int)类型重命名为pf_t
（Ⅶ）函数指针的应用
/*
*实现功能：
*整数的加减乘除计算
*/
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;//除法
}
//调用Cala()函数进行计算
void Calc(int (*ASMD)(int, int)) {//回调函数
//int(*)(int,int)函数指针类型
int x = 0;
int y = 0;
int ret = 0;
printf("输入两个操作数>>");
scanf("%d %d", &x, &y);
ret = ASMD(x, y);
printf("%d\n", ret);
}
int main(){
int Mode = 0;
while (Mode != 5) {
//Start
printf("--------------------------------\n");
printf("----------1.Add--2.Sub----------\n");
printf("----------3.Mul--4.Div----------\n");
printf("-------------5.Exit-------------\n");
printf("--------------------------------\n");
printf("选择模式（1-5）：");
scanf("%d", &Mode);
switch (Mode) {
case 1:
Calc(Add);
break;
case 2:
Calc(Sub);
break;
case 3:
Calc(Mul);
break;
case 4:
Calc(Div);
break;
case 5:
printf("退出计算！\n");
break;
default:
printf("输入错误！\n");
break;
}
}
return 0;
}
-
-------------------------------- ----------1.Add--2.Sub---------- ----------3.Mul--4.Div---------- -------------5.Exit------------- -------------------------------- 选择模式（1-5）：1 输入两个操作数>>5 6 11 -------------------------------- ----------1.Add--2.Sub---------- ----------3.Mul--4.Div---------- -------------5.Exit------------- -------------------------------- 选择模式（1-5）：3 输入两个操作数>>5 6 30 -------------------------------- ----------1.Add--2.Sub---------- ----------3.Mul--4.Div---------- -------------5.Exit------------- -------------------------------- 选择模式（1-5）：5 退出计算！
六、函数指针数组
即存放函数指针的数组，函数指针数组允许你将多个函数存储在一个数组中，并通过索引来调用这些函数
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;//除法
}
int main() {
int (*arr[4])(int, int) = { Add,Sub,Mul,Div };//arr就是函数指针的数组
//遍历这个数组
int i = 0;
for (i = 0; i < 4; i++) {
int num = arr[i](8, 2);
printf("%d ", num);
}
return 0;
}
int (*arr[4])(int, int) = { Add,Sub,Mul,Div };
- 新建并初始化函数指针数组
arr[i](8, 2);调用数组中的元素 （函数指针） ，并传递两个常量参数给函数
七、指向函数指针数组的指针
- 指向函数指针数组的指针是一个指针，它指向一个数组，而这个数组的每个元素都是指向函数的指针
int main() {
//pfArr就是函数指针的数组
int (*pfArr[4])(int, int) = { Add,Sub,Mul,Div };
//指向【函数指针数组】的指针
int(*(*ppfArr)[4])(int, int) = &pfArr;
return 0;
}
八、回调函数
⭐️ 回调函数是一种编程技术，可以将函数（例如函数
Add()）作为参数传递给另一个函数（例如函数Calc()），并可以在将来某个时间点通过该函数（Calc()）来的间接调用函数（Add()）
#include <stdio.h>
// 定义一个回调函数类型
typedef void (*Callback)(int);
// 定义一个回调函数
void printNumber(int number) {
printf("The number is: %d\n", number);
}
// 定义一个接受回调函数作为参数的函数
void processNumber(Callback callback, int number) {
// 在这里执行一些操作...
// 然后调用回调函数
callback(number);
}
int main() {
// 调用processNumber，传递printNumber作为回调函数
processNumber(printNumber, 42);
return 0;
}
-
-
printNumber是一个回调函数，它接受一个整数参数并打印它。 -
processNumber是一个接受回调函数作为参数的函数，它在执行一些操作后调用回调函数。 -
在
main函数中，我们传递printNumber作为回调函数给processNumber，并传递数字42作为参数。 -
当
processNumber完成其操作后，它会调用printNumber来处理数字42。
-
（Ⅰ）qsort( )快速排序算法
-
qsort()可以排序任意类型的数据（包括但不限于整数、浮点数、结构体类型的数据等） -
qsort是 C 语言标准库中的一个函数，用于对数组进行排序。 -
它是一个快速排序算法的实现，可以在
O(n log n)的平均时间复杂度内完成排序。 -
qsort函数的定义在<stdlib.h>头文件中，如下所示：
void qsort(void *base,
size_t num,
size_t size,
int (*comparator)(const void *e1, const void *e2));//函数指针（比较函数）
参数说明：
base：指向要排序数组的指针
num：数组中的元素数量
size：每个元素的大小（以字节为单位）
comparator：指向一个比较函数的函数指针，e1是需要比较的第一个元素，e2是需要比较的第二个元素
对于
comparator函数指针指向的函数cmp_int(count void* e1,const void* e2)的返回值：
返回值 比较 <0e1<e20e1=e2>0e1>e2
-
void*介绍 -
void*类型的指针被称为空类型指针或泛型指针。它可以指向任何类型的数据void*指针的主要特点是它不提供关于其所指向数据类型的任何信息，因此它不能解引用和*±指针*void*指针的关键点：-
类型转换：由于
void*指针不包含关于其所指向数据类型的信息，因此在将void*指针赋值给其他类型的指针之前，必须进行强制类型转换。这是因为编译器需要知道目标指针的类型，以便正确地解释指针所指向的数据void* ptr = /* ... */; int* intPtr = (int*)ptr; // 强制类型转换 -
用途：
void*指针常用于函数参数中，以允许函数接受任何类型的指针。例如，qsort函数和memcpy函数都使用void*类型的参数来处理不同类型的数据 -
内存分配：
void*指针也常用于动态内存分配。例如，malloc和calloc函数返回void*类型的指针，因为它们分配的内存可以用于存储任何类型的数据int* array = (int*)malloc(10 * sizeof(int)); // 分配内存并类型转换
-
1、排序整型数组
//qsort快速排序
void cmp_int(const void* e1, const void* e2) {
return (*(int*)e1 - *(int*)e2);//升序
//return -(*(int*)e1 - *(int*)e2);//降序
}
int main() {
int arr[10] = { 2,0,5,6,9,12,5,8,3,7 };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);//回调函数，间接调用了cmp_int
int i = 0;
for (i = 0; i < sz; i++) {
printf("%d ", arr[i]);
}
return 0;
}
- 这里使用
qsort()函数可以轻易的将整型数组进行升序或降序
2、排序结构体类型的数组
//使用qsort()排序结构体数据
//********************************
struct Stu//创建结构体变量：Stu
{
char name[10];
int age;
};
//********************************
int cmp_Stu_name(const void* e1, const void* e2) {
//按照姓名排序
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);//升序
}
//********************************
int cmp_Stu_age(const void* e1, const void* e2) {
//按照年龄排序
return (((struct Stu*)e1)->age) - (((struct Stu*)e2)->age);//升序
}
//********************************
//打印学生信息
void print_Stu(struct Stu* Nam,int sz) {
int i = 0;
for (i = 0; i < sz; i++) {
printf("%s ", Nam[i].name);
printf("%d ", Nam[i].age);
printf("\n");
}
printf("\n");
}
//********************************
void Test_2() {
struct Stu Date[4] = { {"张三",20},{"李四",23},{"王五",21},{"赵六",20} };
int sz = sizeof(Date) / sizeof(Date[0]);
print_Stu(Date, sz);
qsort(Date, sz, sizeof(Date[0]), cmp_Stu_name);//按姓名排序
//qsort(Date, sz, sizeof(Date[0]), cmp_Stu_age);//按年龄排序
print_Stu(Date, sz);
}
//********************************
int main() {
Test_2();
return 0;
}
-
strcmp()函数可以比较两个字符串，且返回值有以下几种情况：- 小于0：如果第一个字符串在字典顺序上小于第二个字符串，
strcmp返回的值小于0。- 例如，字符串 “apple” 和 “banana” 比较， “apple” 在字典顺序上排在 “banana” 之前，所以
strcmp("apple", "banana")会返回一个负数
- 例如，字符串 “apple” 和 “banana” 比较， “apple” 在字典顺序上排在 “banana” 之前，所以
- 等于0：如果两个字符串完全相同，
strcmp返回0- 例如，
strcmp("hello", "hello")会返回0
- 例如，
- 大于0：如果第一个字符串在字典顺序上大于第二个字符串，
strcmp返回的值大于0- 例如，字符串 “zebra” 和 “apple” 比较， “zebra” 在字典顺序上排在 “apple” 之后，所以
strcmp("zebra", "apple")会返回一个正数
- 例如，字符串 “zebra” 和 “apple” 比较， “zebra” 在字典顺序上排在 “apple” 之后，所以
- 小于0：如果第一个字符串在字典顺序上小于第二个字符串，
-
按照姓名排序 张三 20 李四 23 王五 21 赵六 20 赵六 20 张三 20 王五 21 李四 23
（Ⅱ）基于冒泡排序 模拟实现qsort()
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//交换dat_1和dat_2
void Swap(char* dat_1, char* dat_2, int size) {
int i = 0;
for (i = 0; i < size; i++) {
char temp = *dat_1;
*dat_1 = *dat_2;
*dat_2 = temp;
dat_1++;
dat_2++;
}
}
//模拟实现qsort()，使用方法同qsort()
void bubble_sort(void* base, size_t sz, size_t size, int (*cmp)(const void* e1, const void* e2))
{
size_t i = 0;
for (i = 0; i < sz; i++) {
size_t 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);
}
}
}
}
-
将
base强制转换为char*类型的原因：-
由于
base是void*类型，不能直接对其进行算术运算（比如加法或减法）来移动指针（void*指针不支持直接的算术运算） -
将
base转换为char*类型的指针允许进行这种算术运算，因为char*指针可以被看作是一个指向字节的指针。通过将base转换为char*，就可以在指针上进行加法和减法操作，每次增加或减少的量是单个字符的大小（即1字节） -
这样，就可以通过增加或减少指针的值来访问数组中的不同元素。
-
例如，有一个整数数组，每个整数的大小是4字节，那么要访问数组中索引为
j的元素，你可以将char*类型的指针增加j * 4个字节。这样，指针就会指向数组中正确的整数。
-
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
