文章目录
在前面的学习中，我们已经知道了指针的基本概念和初级用法：
- 指针就是一个存放地址的变量，地址标识内存中唯一的一块空间。
- 指针的大小是固定的 4字节/ 8字节(32位平台/ 64位平台）。
- 指针是有类型的，指针的类型决定了指针 ± 整数时的步长，和指针解引用时的权限大小。
- 指针的基本运算。
下面我们将学习指针的高级用法。
一、字符指针
char*
一般使用：
#include<stdio.h>
int main()
{
char a = 'c';
char* pa = &a;
*pa = 's';
printf("%c", *pa);
return 0;
}
还有另一种使用方法：
#include<stdio.h>
int main()
{
// 这里是将字符串常量 "hello world!" 的首字符的地址放入指针变量 pstr。
// 而不是将字符串本身放入指针变量。
const char* pstr = "hello world!";
printf("%s", pstr);
return 0;
}
那我们接下来看这段代码：
#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 == str2 \n");
else
printf("str1 != str2\n");
if(str3 == str4)
printf("str3 == str4\n");
else
printf("str3 != str4\n");
return 0;
}
他的输出是这样子的，为什么会有这样的区别呢？
这里的 str3 和 str4 指向的是同一个常量字符串，C/C++ 会将常量字符串存储到单独的一个内存区域，几个指针去指向同一各字符串时，它们指向的是同一块内存。
但是用字符串初始化数组时，两个数组在内存中会开辟不同的内存块，所以 str1 和 str2 不同。
二、指针数组
指针数组是一个存放指针的数组。
int * arr[10]; // 整型指针的数组
char* arr2[10]; // 字符指针的数组
char** arr3[10];// 二级字符指针的数组
使用：
#include<stdio.h>
int main()
{
int arr1[5] = { 0,1,2,3,4 };
int arr2[5] = { 4,2,3,4,3 };
int arr3[5] = { 6,7,8,9,4 };
int* parr[3] = { arr1,arr2,arr3 };
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 5; j++)
{
//printf("%d ", parr[i][j]);
printf("%d",*(parr[i]+j));
}
printf("\n");
}
return 0;
}
三、数组指针
3.1 数组指针的定义
前面已经学习过指针数组是个数组，那么数组指针是什么？
答案是：指针。
指向数组的指针
int a[10];
int (*pa)[10] = &arr;
// pa 是一个数组指针，它的类型为 int (*)[10];
// 解释：pa 先和 * 结合，说明 pa 是一个指针变量，指向的是一个大小为 10 个整型的数组。
// [10] 表示指向的数组的大小为 10 .
// pa 就是一个指向数组的指针,也就是一个数组指针。
3.2 数组名 和 &数组名
我们知道数组名表示的是数组首元素的地址，那么 数组名 和 &数组名表示的意思相同吗？
让我们看下面的代码：
#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 数组指针的使用
通过上面的内容我们知道了数组指针的定义，还有&arr 和 arr 的区别。
那么数组指针到底该怎么使用呢？
有下面的代码：
#include<stdio.h>
int main()
{
int arr[10] = {0,1,2,3,4,5,6,7,8,9};
int (*p)[10] = &arr;
// 一般不会这样子写代码。
}
#include<stdio.h>
void printArr1(int arr[3][5], int row, int col)
{
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
printf("%-2d ",arr[i][j]);
}
printf("\n");
}
}
void printArr2(int(*parr)[5], int row, int col)
{
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
printf("%-2d ", parr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
printArr1(arr, 3, 5);
printf("\n");
// 数组名 arr 表示的是数组首元素的地址
// 二维数组的首元素是二维数组的第一行
// 这里传递的 arr ，相当于二维数组的第一行的地址
// 所以可以使用数组指针来接收
printArr2(arr, 3, 5);
return 0;
}
上面的第二种写法就是数组指针的基本用法，可以看到这两种写法的效果是一样的。
3.4 分辨几种混合表示
int arr[5];
// arr 是一个整型数组，每个元素都是 int 类型的，一共5个元素。
int *parr1[5];
// parr1 是一个指针数组，每个元素类型都是 int* ，5 个元素。
int (*parr2)[5];
// parr2 是一个指向数组的指针，指向的数组每个元素都是 int ，且有 5 个元素。
int (*parr3[10])[5];
// parr3 是一个存放数组指针的数组，数组有 10 个元素，每个元素类型都是 int (*p)[5].
四、数组参数、指针参数
我们进行程序设计时总是要将 数组和指针传给函数，那么函数的参数该如何设计呢？
4.1 一维数组传参
// 指针形式的传参
void test(int* arr);
// 数组形式的传参
void test2(int arr[]);
void test3(int arr[10]);
void test4(int arr[100]);
// 总结：上面的几种一维数组传参方法都是可行的。
// 传参时传入的是首元素的地址，[] 内的数字并不代表数组的大小。也可以什么都不写
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
test(arr);
}
4.2 二维数组传参
void test1(int arr[3][5]);
void test2(int arr[][5]);
void test3(int arr[][]); // NO
// 总结: 二维数组传参，形参只能省略第一个[]内的数字。
// 因为对于一个二维数组，可以不知道有多少行，但是一定要知道一行有多少元素。
void test(int* arr);
void test(int* arr[5]);
void test(int** arr);
// 以上三种表示都是错误的，
void test(int(*arr)[5]);
// 数组指针，可以存放数组的地址，可行，
int main()
{
int arr[3][5] = { 1,2,3,4,5,6,7,8,9,11,12,13,14,15 };
return 0;
}
4.3 一级指针传参
void print(int* arr, int size)
{
for (int i = 0; i < size; i++)
{
printf("%d ", *arr + i);
}
}
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
int size = sizeof(arr) / sizeof(arr[0]);
// 一级指针，传给函数。
print(arr, size);
return 0;
}
4.4 二级指针传参
void test(int** p)
{
printf("%d\n", **p);
}
int main()
{
int n = 321;
int* p = &n;
int** pp = &p; // pp 就是一个二级指针，存放一级指针 p 的地址。
test(pp);
test(&p); // 传入的是一个一级指针的地址，相当于二级指针。
return 0;
}
思考一下，如果函数参数为二级指针，那么它都可以接收什么类型的参数呢？
五、函数指针
5.1 函数指针的定义
我们前面知道了数组指针是一个指向数组的指针。
其实函数指针就是指向函数的指针。
那么我们该如何得到一个函数的地址呢？
int Add(int x,int y)
{
return x + y;
}
int main()
{
printf("%p\n", Add);
printf("%p", &Add);
}
得到的是两个地址，Add 和 &Add 表示的都是函数的地址。
接下来我们要将函数指针保存进一个指针变量
int Add(int x,int y)
{
return x + y;
}
int main()
{
printf("%p\n", Add);
int (*pAdd)(int, int) = &Add;
// 解释：第一个 int表示函数的返回类型， *先和 pAdd 结合，说明 pAdd 是一个指针变量，
// (int ,int) 是函数的形参的类型。
printf("%p", pAdd);
}
5.2 函数指针的使用
函数指针的使用十分简单
int Add(int x,int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = &Add;
int ret = (*pf)(2,4);
int ret2 = pf(2,4);
// pf 和 (*pf) 表达的意思是一致的。
printf("%d",ret); // 6
}
了解了函数指针之后，下面我们来看两段有意思的代码。
// 代码1
( *( (void (*)()) 0 )) ();
// 代码2
void (*signal(int , void(*)(int)))(int);
正常人看到这样的代码肯定都会抓狂吧，这两段代码到底都是什么意思呢？
下面来为大家解答：
- 代码1
( *( (void (*)()) 0 )) ();
void (*)() 是函数指针类型
(void (*)()) 进行强制类型转换
(void (*)()) 0 将 0 强制转换成函数指针类型
*(指针) 是解引用操作。
// 1. 首先将 0 强制类型转换为一个函数指针类型，这意味着 0 地址处存放一个
// 类型为 void ,无参的函数。
// 2. 调用 0 地址处的函数。
- 代码2
void (*signal(int , void(*)(int)))(int);
// signal 是一个函数的声明
// signal 函数有两个参数，第一个参数 int 类型，第二个参数是 void(*)(int)的函数指针类型
// signal 函数的返回值类型也是 void(*)(int) 的函数指针
// void (*)(int) signal(int , void(*)(int));
// 代码变形一下更容易理解，但是注意这是错误写法。
typedef void(* pf)(int); // 给函数指针类型 void(*)(int) 重新命名为 pf
pf signal(int,pf); // 代码简化
六、函数指针数组
6.1 函数指针数组的定义
数组是一个存放相同类型数据的存储空间，前面我们已经学习过了指针数组：
int *arr[10];
// 数组每个元素为 int*
如果把函数的地址放到一个数组中，那这个数组就叫函数指针数组，那它是如何定义的呢？
int (*parr[10]) ();
// parr 先和 [] 结合，说明 parr 是一个数组，数组的内容是什么呢？
// int(*)() 类型的函数指针。
6.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;
scanf("%d %d", &x, &y);
// 转移表
int(*pf[])(int x,int y) = { Add,Sub,Mul,Div };
for (int i = 0; i < 4; i++)
{
printf("%d\n", pf[i](x, y));
}
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;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
int(*pf[])(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 >= 1 && input <= 4)
{
printf("请输入操作数：");
scanf("%d %d", &x, &y);
ret = pf[input](x, y); // 函数调用
printf("%d\n", ret);
}
else if (input == 0)
{
printf("退出");
}
else
{
printf("输入错误");
}
}
return 0;
}
实际上，函数是通过函数地址调用的
6.3 指向函数指针数组的指针
指针指向一个数组，数组里的元素都是函数指针。
如何定义呢？
int arr[10] = {0,1,2,3,4,5,6,7,8,9};
int (*p)[10] = &arr; // 数组指针
int* arr[10];
int* (*P2)[5] = &arr2; // p2 是指向指针数组的指针
// 函数指针
int (*pf)(int,int) = &Add;
// 函数指针数组
int (* pfarr[4])(int,int); // 四个数据，每个函数参数都是两个 int
// 指向函数指针数组的指针
int (* (*ppfarr)[4]) (int,int) = &pfarr;
下面这张图可以具体说明他们的关系：
// 解引用对应关系
*ppfarr = pfarr;
*ppfarr[i] = pfarr[i];
*ppfarr + i = pfarr[i];
七、回调函数
回调函数的本质是函数的嵌套调用。
回调函数就是一个通过函数指针调用的函数。如果把函数的指针作为函数参数传递给一个函数，当这个函数被用来调用其所指向的函数时，我们就说这是回调函数。
- 一个简单应用
#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, y;
printf("请输入操作数：");
scanf("%d%d", &x, &y);
printf("%d\n", pf(x, y));
}
int main()
{
int input = 1;
int(*pf[])(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 >= 1 && input <= 4)
{
// 回调函数
calc(pf[input]);
}
else if (input == 0)
{
printf("退出");
}
else
{
printf("输入错误");
}
}
return 0;
}
7.1 qsort 函数
C语言库函数中的 qsort 函数是一个经典的回调函数，下面来演示一下 qsort 的使用：
qsort()函数基于快速排序实现，可以排任何类型的数据
qsort 有四个参数
// 比较函数
int cmp(const void* a, const void* b)
{
// return *(int*)b - *(int*)a; 降序
return *(int*)a - *(int*)b; // 升序
}
int main()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
int i = 0;
// qsort 函数
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), cmp);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
上面的代码用到了 void* :
void* 是无类型指针，无论什么类型的数据都可以接收。
void* pf = &a;
pf+1; // error
*pf; // error
// 上面两种使用方法都是错的，前面说 void* 是无类型指针，使用前必须进行强制类型转换
int cmp(const void* a, const void* b)
{
// 强制类型转换
return *(int*)a - *(int*)b;
}
7.1.2 qsort 进行结构体排序
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
struct student {
char name[20];
int age;
};
int cmp1_by_age(const void* a, const void* b)
{
// 强制类型转换 并 返回
return ((struct student*)a)->age - ((struct student*)b)->age;
}
int cmp2_by_name(const void* a, const void* b)
{
// 强制类型转换 并 返回
return strcmp(((struct student*)a)->name ,((struct student*)b)->name);
}
// strcmp(str1,str2) 函数是字符串比较函数，按照字典序进行比较，str1 > str2 返回 1， 相等时返回 0
int main()
{
struct student arr[] = { {"zhangsan",18},{"lisi",19},{"wangwu",16}};
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), cmp1_by_age);
return 0;
}
7.1.3 用冒泡排序模拟实现 qsort 函数
int int_cmp(const void* a, const void* b)
{
// 升序排序
return *(int*)a - *(int*)b;
// a > b 1
// a = b 0
// a < b -1
}
void Swap(void* p1,void* p2,int size)
{
// 细分到字节的交换
int i;
for (i = 0; i < size; i++)
{
// char 类型指针解引用只作用到一个字节，这样两个 参数 的每个对应字节数据都被交换
// ，两个参数就被交换了。
char temp = *((char*)p1+i);
*((char*)p1 + i) = *((char*)p2 + i);
*((char*)p2 + i) = temp;
}
}
void bubble_qsort(void* base, int cnt, int size, int(*cmp)(const void*, const void*))
{
// 冒泡排序
int i, j;
for (i = 0; i < cnt - 1; i++)
{
for (j = 0; j < cnt - i - 1; j++)
{
/* 为了让自己的 qsort 有普适性，可以排序任何类型的数据，
* 将数据强制转化为 char 类型的，后续操作可以精确到每个字节。
*/
// cmp ( arr[j] , arr[j+1] );
// (char*)base + j * size == arr[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[] = { 1,56,3,5,2,4,6,9,8,0 };
int cnt = sizeof(arr) / sizeof(arr[0]);
// 模拟 qsort 函数
bubble_qsort(arr, cnt, sizeof(arr[0]), int_cmp);
for (int i = 0; i < cnt; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
扫一扫
3152
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
