【C语言】指针的进阶
目录
在之前初阶指针中，我们已经接触到了
- 指针就是变量，用来存放地址的变量，地址可以标识一个内存空间
- 指针是有类型的，指针的类型决定了指针 +- 整数的步长，以及指针解引用时权限
- 指针的大小是固定的4/8字节（32位/64位平台）
- 指针的运算
接下来是指针的进阶
一、字符指针
1.
在指针的类型中有一个是 char *
//操作一个字符
#include<stdio.h>
int main()
{
char ch = 'x';
char* pc = &ch;
*pc = "a";
return 0;
}//操作字符串
#include<stdio.h>
int main()
{
const char* str = "abcdef";
printf("%s",str);
return 0;
}注意：上述的代码 const char* str = "abcdef"; 我们平时可能认为 把字符串放到 str 里面了，但是本质上是把首字符的地址放到str里面。如下图
就是把 字符串中的首字符 a 的地址 0x1122334 存到指针变量 str 中
2.
【例】判断输出结果
//数组与字符指针的指向问题
#include<stdio.h>
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdef";
const char* str1 = "abcdef";
const char* str2 = "abcdef";
if (arr1 == arr2)
printf("arr1 and arr2 are samen");
else
printf("arr1 and arr2 are not samen");
if (str1 == str2)
printf("str1 and str2 are samen");
else
printf("str1 and str2 are not samen");
return 0;
}【结果】
解析： 数组名 一般情况是 数组首元素的地址，arr1与arr2是两个不同的数组名，虽然存放这相同的常量字符串，arr1 与 arr2 是指向不同的内存块，只是这两个内存放着相同内容。
而 str1 与 str2 是 指向的是 同一个常量字符串，指向的是同一块内存，str1 和 str2 相同
二、指针数组
指针数组 是 存放指针的 数组（数组中的每一个元素都是指针）
指针数组的使用
（1）
//指针数组的使用
#include<stdio.h>
int main()
{
char* str0 = "abc";
char* str1 = "aaa";
char* str2 = "bbb";
char* arr[] = {str0,str1,str2};
printf("%sn%sn%sn",arr[0],arr[1],arr[2]);
return 0;
}（2）使用指针数组模拟一个二维数组
//指针数组模拟二维数组
#include<stdio.h>
int main()
{
int arr1[3] = {1,2,3};
int arr2[3] = {4,5,6};
int arr3[3] = {7,8,9};
int* arr[3] = {arr1,arr2,arr3};
int i = 0;
for (i = 0; i < 3;i++)
{
int j = 0;
for (j = 0; j < 3;j++)
{
printf("%d ",arr[i][j]);
}
printf("n");
}
return 0;
}三、数组指针
数组指针是指向数组的指针
我们在前面已经了解到
整型指针 （int * a;）指向整型数据的指针
浮点型指针（float * pf;）指向浮点型数据的指针
那么数组指针 就是 能够指向数组(型)数据的指针
1.数组指针的定义
int (*p) [10];
注意: [ ]的优先级 高于 * ，所以 要加上（）来保证p 先和 * 结合
2.&数组名和数组名区别
经过前面数组的学习 我们了解到 &arr 与 arr 所打印的值 一样的，但是 意义不一样
回想一下
arr 是数组首元素的地址
&arr 表示的是数组的地址，而不是数组首元素的地址
&arr的类型是 int (*) [10],是一种 数组指针 的类型
arr+1 跳过的是数组元素大小，而 &arr + 1 与 &arr 的 差值是 一个数组的大小
3.数组指针的使用
数组指针 指向的是 数组，那 数组指针中存放的应该是 数组的地址
//数组指针的使用
#include<stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int(*pa)[10] = &arr;//把数组arr的地址赋值给数组指针变量pa
//上述其实我们一般很少这样写
return 0;
}数组指针的使用
#include<stdio.h>
void Print_arr(int (*arr)[3] ,int row,int col)
{
int i = 0;
for (i = 0; i < row;i++)
{
int j = 0;
for (j = 0; j < col;j++)
{
printf("%d ",arr[i][j]);
}
printf("n");
}
}
int main()
{
int arr[3][3] = {1,1,1,2,2,2,3,3,3};
Print_arr(arr,3,3);
//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
//可以数组指针来接收
return 0;
}【练习】看看下方代码的意思
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];【结果】
- 存放 5个 整型元素的数组
- 存放10个整型指针元素的数组
- 指向 一个存放10个整型元素的 数组的指针
- parr3[10]是一个数组， 一个存放 10个数组指针元素的 数组, 每一个元素的类型是 数组指针 (数组指针，指向的数组有 5个元素 ，每一个元素的类型是int )
四、数组参数与指针参数
数组传参：参数可以写完为数组的形式
1.一维数组传参
void test(int arr[])
{}
void test(int arr[10])
{}
void test(int* arr)
{}
void test2(int* arr[20])
{}
void test2(int** arr)
{}2.二维数组传参
二维数组传参写成数组的形式的时候 int arr[ ] [ 3],可以不知道有多少行，但是必须知道一行有多少元素
void test(int arr[3][5])
{}
void test(int arr[][5])
{}
void test(int(*arr)[5])
{}3.一级指针传参
#include <stdio.h>
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%dn", *(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;
}4.二级指针传参
#include <stdio.h>
void test(int** ptr)
{
printf("num = %dn", **ptr);
}
int main()
{
int n = 10;
int* p = &n;
int** pp = &p;
test(pp);
test(&p);
return 0;
}五、函数指针
&函数名 是函数的地址
函数名 也是函数的地址
#include <stdio.h>
void test()
{
printf("hehen");
}
int main()
{
printf("%pn", test);
printf("%pn", &test);
return 0;
}【结果】
函数指针的定义
void (*test) ();test先和*结合，说明test是指针，指针指向的是一个函数，指向的函数无参
数，返回值类型为void
【练习】分析下方代码
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);代码1
是 调用0地址处的函数，这个函数没有参数，返回类型为void
代码2
是 一次函数声明 ，声明的是signal 函数，signal函数的参数有两个，一个是int 类型,一个是void(*)(int)类型，该类型，函数指针类型 ，指向的函数参数是int ,返回类型是 void
signal函数的返回类型也是函数指针类型，void(* ) (int),该类型，函数指针类型 ，指向的函数参数是int ,返回类型是 void
六、函数指针数组
函数指针数组：是数组，数组的每一个元素是函数指针类型
int (* parr[10])();
函数指针数组的用途：转移表
接下来 我们先简单地写一个 两个正整数 进行加减乘除的 小程序， 见下方代码
#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 input = 0;
int x = 0;
int y = 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("ret = %dn",ret);
break;
case 2:
printf("请输入操作数：");
scanf("%d %d", &x, &y);
ret = sub(x, y);
printf("ret = %dn", ret);
break;
case 3:
printf("请输入操作数：");
scanf("%d %d", &x, &y);
ret = mul(x, y);
printf("ret = %dn", ret);
break;
case 4:
printf("请输入操作数：");
scanf("%d %d", &x, &y);
ret = div(x, y);
printf("ret = %dn", ret);
break;
case 0:
printf("退出计算器n");
break;
default:
printf("输入错误，请重新输入n");
break;
}
}
while (input);
return 0;
}
分析 一下上述代码 我们发现在 switch 语句中 大量出现输入输出 的 代码冗余
因为用到多个函数，其实 我们可以使用函数指针数组 来进行 代码的大幅度简化
#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 input = 0;
int x = 0;
int y = 0;
int ret = 0;
//用函数指针数组来存放
int (*parr[5])(int, int) = {NULL,add,sub,mul,div};//转移表
// 0 1 2 3 4
do {
menu();
printf("请选择：>");
scanf("%d", &input);
if (input >=1&&input<=4)
{
printf("请输入操作数:>");
scanf("%d %d",&x,&y);
ret = parr[input](x,y);
printf("ret = %dn",ret);
}
else if (input == 0)
printf("退出计算器n");
else
printf("输入错误，请重新输入n");
}
while(input);
return 0;
}
当然函数指针数组并不仅仅是转移表，函数指针数组在具体项目中起到的作用还是很多。
七、指向函数指针数组的指针
函数指针数组 的指针 ： 是指针
指针 指向 一个数组，数组的元素类型都是 函数指针
指向 函数指针数组 的指针 ，感觉很绕口 有点像套娃
那 再看这个 存放 指向 函数指针数组 的 指针 的数组
指向函数指针数组的指针
int(* (*p)[4])(int,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;
}
void calcu(int(*pf)(int,int))
{
int x = 0;
int y = 0;
printf("请输入两个操作数：");
scanf("%d %d",&x,&y);
int ret = pf(x,y);
printf("ret = %dn",ret);
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do {
menu();
printf("请选择：>");
scanf("%d", &input);
switch (input)
{
case 1:
calcu(add);
break;
case 2:
calcu(sub);
break;
case 3:
calcu(mul);
break;
case 4:
calcu(div);
break;
case 0:
printf("退出计算器n");
break;
default:
printf("输入错误，请重新输入n");
break;
}
} while (input);
return 0;
}
1.回调函数 模拟 qsort函数
首先我们先了解一下 qsort 函数
qsort 函数 ：快速排序，适合于任意元素类型，qsort 默认为升序
作用 Sort elements of array 对数组元素进行排序
Sorts the num elements of the array pointed to by base, each element size bytes long, using the compar function to determine the order
将数组中指向的num个元素按基数(每个元素的长度为字节)排序，使用compar函数确定顺序
void qsort (void* base, size_t num, size_t size,int (*compar)(const void*,const void*));看下图
我们平时排序（升序或者降序）可能会想到冒泡排序，当然冒泡排序也是可以的，但是冒泡排序所排序的元素还是 有一定限制的，如果排字符串，排结构体呢，显然冒泡排序是不合适的，那木这时 qsort 函数是可以胜任的
【练习】使用qsort 进行排序
#include<stdio.h>
#include<stdlib.h>
int int_cpm(const void*p1,const void *p2)
{
return (*(int*)p1 - *(int*)p2);
}
int main()
{
int arr[] = {2,1,4,3,5,6,9,7,8,10};
int num = sizeof(arr) / sizeof(arr[0]);
int i = 0;
qsort(arr,num,sizeof(int),int_cpm);
for (i = 0; i < num;i++)
{
printf("%d ",arr[i]);
}
return 0;
}
在上述代码中 ，出现了 void *
那先介绍一下 void * 的作用， 然后再分析代码
void * 指针
- 这是无具体类型的指针
- 可以接收任意类型的地址
- 这种类型的指针是不直接解引用操作的，也不能直接进行指针运算
有了前面的 qsort 函数的了解，模拟实现qsort函数
#include<stdio.h>
#include<stdlib.h>
int int_cpm(const void* p1, const void* p2)//比较函数
{
return (*(int*)p1 - *(int*)p2);
}
void Swap(void*p1,void*p2,int size)
{
int i = 0;
for (i = 0; i < size;i++)
{
char tmp = *((char*)p1 + i);//一个一个字节进行交换
*((char*)p1 + i) = *((char*)p2 + i);
*((char*)p2 + i) = tmp;
}
}
void my_qsort(void*base,int num,int size,int(*cmp)(void*,void*))
{
int i = 0;
int j = 0;
for (i = 0; i < num - 1;i++)
{
for (j = 0;j<num-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 );
}
}
}
}
int main()
{
int arr[] = { 2,1,4,3,5,6,9,7,8,10 };
int num = sizeof(arr) / sizeof(arr[0]);
int i = 0;
my_qsort(arr, num, sizeof(int), int_cpm);
for (i = 0; i < num; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
这里解释一下核心 交换字节 的原因
要想保证 交换任意元素类型 ，使用int ?使用float？ 这些是不行的
这样的字节交换就保证 可以是任意类型元素进行交换
【练习】对 结构体里面的成员的名字进行 排序
struct Stu s1[] = {{"zhangsan",28},{"wanwu",25},{"John",18}};
#include<stdio.h>
#include<string.h>
struct Stu
{
char name[20];
int age;
};
int cmp_name(const void* p1,const void* p2)
{
return strcmp(((struct Stu*)p1)->name,((struct Stu*)p2)->name);//比较字符串大小
}
void Swap(char *p1,char*p2,int size) //因为字符串 ，一个一个字符交换（正好字符char 是一个字节）
{
//字节单元交换
int i = 0;
char tmp = 0;
for (i = 0; i < size;i++)
{
tmp = *p1;
*p1 =* p2;
*p2 = tmp;
p1++;
p2++;
}
}
void my_qsort(void *base,int num ,int size,int (*cmp)(const void*,const void*))
{
int i = 0;
int j = 0;
for (i = 0; i < num - 1;i++)
{
for (j = 0; j < num - 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);
}
}
}
}
int main()
{
struct Stu s1[] = {{"zhangsan",28},{"wanwu",25},{"John",18}};
int num = sizeof(s1) / sizeof(s1[0]);
my_qsort(s1,num,sizeof(struct Stu),cmp_name);
for (int i = 0; i < num;i++)
{
printf("%sn",s1[i]);
}
return 0;
}