目录
🍎1.常量指针、指针常量
🍌1.1常量指针
语法：const 类型* 变量名；
- const修饰指针
- 指针指向可以修改，指针指向的指针不可以修改
🍌 1.2指针常量
语法： 类型* const 变量名；
- const修饰变量
- 指针指向的值可以改变，指针指向不可以改变
🍌1.3const即修饰指针，又修饰变量
语法： const 类型* const 变量名；
- 指针的指向和指针指向的值都不可以改
🍌代码
int main()
{
int a = 10;
int b = 20;
//1.const修饰的是指针，指针指向可以修改，指针指向的值不可以修改
const int* p1 = &a;
p1 = &b;
//*p1=100;//报错，此表达式左值不可修改
printf("p1=%d\n", *p1);
//2.const修饰的是变量，为指针常量，指针的指向不可以改，指针指向的值可以修改
int* const p2 = &a;
*p2 = 100;
//p2=&b;//报错，指针的指向不可以修改
printf("p2=%d\n", *p2);
printf("a=%d\n", a);
//3.const即修饰指针又修饰常量，指针的指向和指针指向的值都不可以修改
const int* const p3 = &a;
printf("p3=%d\n", *p3);
return 0;
}
🍎2.数组参数、指针参数
🍌2.1一维数组传参
void test(int arr[])//形参是数组
{}
void test(int* arr)//形参是指针
{}
void test(int arr[10])//形参是数组
{}
void text1(int** arr2)//形参是指针
{}
//此处arr2接收的是，数组arr2首元素的地址（以首元素为例）
//第一次解引用，得到数组首元素的值（也是地址）
//第二次解引用，得到首元素值（地址）对应的值
void text1(int* arr[20])//形参是数组
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
text1(arr2);
return 0;
}🍌2.2二维数组传参
void test(int arr1[3][5])
{}
void test(int arr1[][])//错误用法
{}
void test(int arr1[][5])
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr1)//用法错误，
{}
void test(int* arr1[5])
{}
//错误用法，指针数组
//数组传过去需要用指针接收
void test(int (*arr1)[5])
{}
//数组指针是指向数组的指针，接收数组的地址（&arr[0]）
//使用arr1接收二维数组的地址（第一行，一维数组的地址）
//为解引用前，表示一行的地址（类型为int* [5]），解引用后表示类型为int [5]的数组的地址
void test(int** arr1)//错误用法
{}
//二级指针是指向整数的指针的指针
//arr1接收的是二维数组的地址
//二维数组的地址与二维数组第一行的地址，二维数组第一个元素的地址相同，终究只是一个地址
//这个地址所对应的空间存储的是首元素的值，解引用这个地址，得到准确数值而不是另一个地址
//无法再次解引用，故不能使用二级指针
int main()
{
int arr[3][5] = { 0 };
test(arr);
return 0;
}✍数组指针的内存原理
🍌2.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;
}✍思考
当一个函数的参数部分为一级指针的时候，函数能接收什么参数 ？
//1
int a=0;
test(&a);
//2
int* ptr=&a;
test(ptr);
//3
int arr[10];
test(arr);🍌2.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;
}✍思考：
当函数的参数为二级指针的时候，可以接收什么参数？
int a =0;
int* p=&a;
int** pp = &p;
//1
test(pp);
//2
test(&p);
//3.指针数组
int* arr[10];
test(arr);🍎3.函数指针
-
指向函数的指针
void Add(int x,int y)
{
return x + y;
}
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", &arr);
printf("%p\n", Add);
printf("%p\n", &Add);
//Add和&Add都是函数的地址
return 0;
}
🍌参考数组指针
int arr[10] = {0};
int (*p)[10] = &arr;
void add(int a,int b);
void (*p)(int,int) = add;
//void (*p)(int,int) = &add;🍌列1：
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*p)(int, int) = Add;
int a = p(1, 2);
//int a = (*p)(1,2);
//也是可以的
//&Add和Add是相同的地址
printf("%d", a);
return 0;
}🍌列2：
void text(char (*p)[5])
{
for (int i = 0; i < 5; i++)
{
printf("%c ", *(*p + i));
}
printf("\n");
}
int main()
{
char arr[5] = { '1','2','3','4','7'};
char(*p1)[5] = &arr;
void (*p)(char(*)[5]) = text;
p(p1);
return 0；
}🍌分析代码
✍代码1：
(*(void (*)() )0)();✍代码2：
void （ *signal( int,void(*)(int) ) )(int);//声明函数表示函数signal( int,void(*)(int) )的指向int返回值为void
-
上述代码是一次函数声明
-
声明的函数为：signal
-
signal函数的第一个参数是int类型
-
signal函数的第二个参数是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void
-
signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void
✍改写函数
typedef void (*flat1)();
typedef void (*flat2)(int);
(*(flat1)0)();
flat2 signal(int,flat2);🍎4.函数指针数组
//函数指针
int (*p)(int,int);
//函数指针数组
int (*pfArr[])(int,int);
//对比
int* p;//整形指针
int* arr[];//整形指针数组🍌应用：
✍案例1：
#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;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("*************************\n");
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;
}✍案例2：
#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;
}
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);
}
else
printf("输入有误\n");
printf("ret = %d\n", ret);
}
return 0;
}🍎5.指向函数指针数组的指针
//函数指针
int (*pf)(int,int);
//函数指针数组
int (*pfArr[4])(int,int);
//指向函数指针数组的指针
int (*(*ptr)[4])(int,int) = &pfArr;🍎6.回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个 函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
🍌qsort函数
✍使用qsort函数
typedef struct s
{
char name[20];
int age;
}s;
int int_cmp(const void* p1, const void* p2)
{
return (*(int*)p2 - *(int*)p1);
}
int double_cmp(const void* p1, const void* p2)
{
return (*(double*)p2 - *(double*)p1);
}
int char_cmp(const void* p1, const void* p2)
{
return (*(char*)p2 - *(char*)p1);
}
int struct_age_cmp(const void* p1, const void* p2)
{
return (*(s*)p1).age - (*(s*)p2).age;
}
void int_print(void* arr, int num)
{
for (int i = 0; i < num; i++)
{
printf("%d ", *((int*)arr+i));
}
printf("\n");
}
void double_print(void* arr, int num)
{
for (int i = 0; i < num; i++)
{
printf("%.2f ", *((double*)arr + i));
}
printf("\n");
}
void char_print(void* arr, int num)
{
for (int i = 0; i < num; i++)
{
printf("%c ", *((char*)arr + i));
}
printf("\n");
}
void struct_print(void* arr, int num)
{
for (int i = 0; i < num; i++)
{
printf("%s:%d ", ((s*)arr+i)->name,(*((s*)arr+i)).age);
}
}
int main()
{
int arr1[] = { 1,2,3,4,5,6,78,9,10 };
double arr2[] = { 1.2,2.3,2.5,8.9,4.5,6.4,7.5 };
char arr3[] = "abcdef";
s arr4[] = { {"zhangsan",10},{"lisi",20},{"wangwu",18} };
qsort(arr1, sizeof(arr1) / sizeof(arr1[0]), sizeof(arr1[0]), int_cmp);//int类型排序
qsort(arr2, sizeof(arr2) / sizeof(arr2[0]), sizeof(arr2[0]), double_cmp);//double类型排序
qsort(arr3, sizeof(arr3) / sizeof(arr3[0]), sizeof(arr3[0]), char_cmp);//char类型排序
qsort(arr4, sizeof(arr4) / sizeof(arr4[0]), sizeof(arr4[0]), struct_age_cmp);//struct类型排序
int_print(arr1, sizeof(arr1) / sizeof(arr1[0]));
double_print(arr2, sizeof(arr2) / sizeof(arr2[0]));
char_print(arr3, sizeof(arr3) / sizeof(arr3[0]));
struct_print(arr4, sizeof(arr4) / sizeof(arr4[0]));
return 0;
}✍实现qsort函数
typedef struct s
{
char name[20];
int age;
}s;
int cmp(void* p1,void* p2)
{
return (*(s*)p2).age - (*(s*)p1).age;
}
void swap(void* p1, void* p2,int size)
{
//因为传递的类型不明确，无法简单的通过它一个元素的空间的大小确定类型
//强制类型转换为char*类型，并传递它一个元素空间的大小数值过来
//通过循环一个字节，一个字节的传递数值，最终完全传递
for (int i = 0; i < size; i++)
{
char temp = *((char*)p1 + i);
*((char*)p1 + i) = *((char*)p2 + i);
*((char*)p2 + i) = temp;
}
}
void my_psort(void* arr4, int num, int size, int (*cmp)(void*,void*))
{
for (int i = 0; i < num; i++)
{
for (int j = 0; j < num-1-i; j++)
{
if (cmp((char*)arr4+j*size, (char*)arr4 + (j+1) * size) > 0)
{
swap((char*)arr4 + j * size, (char*)arr4 + (j + 1) * size,size);
}
}
}
}
void struct_print(void* arr, int num)
{
for (int i = 0; i < num; i++)
{
printf("%s:%d ", ((s*)arr+i)->name,(*((s*)arr+i)).age);
}
printf("\n");
}
int main()
{
s arr4[] = { {"zhangsan",10},{"lisi",20},{"wangwu",18} };
my_psort(arr4, sizeof(arr4) / sizeof(arr4[0]), sizeof(arr4[0]), cmp);
struct_print(arr4, sizeof(arr4) / sizeof(arr4[0]));
return 0;
} 
261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
