【C语言】指针（进阶）
目录
- 一、字符指针
- 二、数组指针
- 2.1、数组指针的定义
- 2.2、&数组名和数组名
- 2.3、数组指针的使用
- 三、数组传参、指针传参
- 3.1、一维数组传参
- 3.2、二维数组传参
- 3.3、一级指针传参
- 3.4、二级指针传参
- 四、函数指针
- 五、函数指针数组
- 六、指向函数指针数组的指针
- 七、回调函数
一、字符指针
在指针的类型中我们都知道有一种指针类型为字符指针，即char*
下面举个例子：
#include <stdio.h>
int main()
{
char* ps = "abcdef";
printf("%s\n", ps);
return 0;
}
运行结果：
上述例子中很容易理解成把字符串“abcdef”放到字符指针ps里，但是本质上是把字符串的首字符的地址放到ps中。用%s打印字符串只需要知道字符串的首地址。
下面看一道面试题：
#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char* str3 = "hello bit.";
const char* str4 = "hello bit.";
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指向的是一个同一常量的字符串，会单独存储到同一个内存区域中，所以他们指向同一个字符串的时候，他们实际是指向同一个内存区域。但是用相同的常量字符串去初始化不同数组就会开辟不同的空间，所以str1和str2不同，str3和str4相同。
二、数组指针
2.1、数组指针的定义
数组指针是指针还是数组呢？ 当然，是指针，指向数组的指针，存放的是数组的地址
我们都知道：
整型指针：指向整型的指针，是存放整型变量的地址，即int* p
字符指针：指向字符的指针，是存放字符变量的地址，即char* ch
下面我们来看看什么是数组指针：
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int (*pa)[10] = &arr;
pa先和*结合，说明pa是一个指针变量，然后指向一个大小为10个整型的数组，所以pa是一个指针，指向一个数组
2.2、&数组名和数组名
对于下面的数组：
int arr[10];
arr和&arr怎么分别呢？
我们先看一段代码：
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", arr + 1);
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0] + 1);
printf("%p\n", &arr);
printf("%p\n", &arr + 1);
return 0;
}
运行结果：
上述代码中，arr和arr[0]、&arr的地址都是相同的，但是他们都加1呢？
加1后，arr和arr[0]还是相同的，他们都表示的是首元素跳过一个整型，下一个元素的地址。
而&arr则与arr的差值是40，表示的是跳过了整个数组。
综上所述：&arr表示的是整个数组的地址，而不是数组首元素的地址。
2.3、数组指针的使用
先举个例子：
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
int(*p)[10] = &arr;
for (int i = 0; i < sz; i++)
{
printf("%d ", (*p)[i]);
}
return 0;
}
上述代码中，把数组arr的地址赋给数组指针变量p中，但是我们很少这样去写一维数组。
下面我们有数组指针来实现二维数组：
#include <stdio.h>
void print(int(*p)[5], int rol, int col)
{
int i = 0;
int j = 0;
for (i = 0; i < rol; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", *(*(p + i) + j));
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
print(arr, 3, 5);
return 0;
}
运行结果：
上述代码中，由于二维数组的首元素就是二维数组的第一行，所以这里传的arr是二维数组的第一行，相当于一维数组的地址，可以用数组指针来接收。
我来看看下面代码表示什么意思：
int arr[5];
int* parr1[10];
int(*parr2)[10];
int(*parr3[10])[5];
第一个表示整型数组
第二个表示指针数组
第三个表示数组指针
第四个也是数组指针，其中*parr3[10]可看做指针数组，用来存放数组指针的数组
三、数组传参、指针传参
3.1、一维数组传参
我们看看下面传参那些是正确的：
#include <stdio.h>
void test(int arr[]) // true，形参是数组
{}
void test(int arr[10]) // true，形参是数组
{}
void test(int* arr[]) // true，形参是指针
{}
void test2(int* arr[20]) // true，形参是数组
{}
void test2(int** arr) // true，形参是指针
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
return 0;
}
3.2、二维数组传参
我们看看下面传参那些是正确的：
#include <stdio.h>
void test(int arr[3][5]) // true
{}
void test(int arr[][]) // error 行可以省略，列不可以省略
{}
void test(int arr[][5]) // true
{}
void test(int* arr) // error
{}
void test(int* arr[5]) // error
{}
void test(int(*arr)[5]) // true
{}
void test(int** arr) // error 二级指针接收的是一级指针的地址
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
}
3.3、一级指针传参
我们举个例子：
#include <stdio.h>
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
print(p, sz);
return 0;
}
如果当一个函数的参数部分为一级指针的时候，函数又能接收什么参数呢？
void print(int* p)
上述函数中，可接收以下参数：
int a=0; int* ptr = &a; int arr[10];
print(&a); print(ptr); print(arr);
3.4、二级指针传参
看个例子：
#include <stdio.h>
void test(int** ptr)
{
printf("%d\n",**ptr);
}
int main()
{
int n = 10;
int* p = &n;
int** pp = &p;
test(pp);
test(&p);
return 0;
}
如果当一个函数的参数部分为二级指针的时候，函数又能接收什么参数呢？
void test(int** ptr);
上述函数中，可接收以下参数：
int** ptr; int* p2; int* arr[10];
test(ptr); test(&p2) test(arr);
四、函数指针
函数指针是指向函数的指针
下面我们看一段代码：
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
printf("%p\n", Add);
printf("%p\n", &Add);
return 0;
}
运行结果：
由上述结果可知Add和&Add都是函数的地址，那么我们应该怎样保存函数的地址呢？
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int x, int y) = Add; // Add也可写成&Add
int sum = (*pf)(3, 5);
printf("%d", sum); // 8
return 0;
}
上述代码中，pf是指针，指向的是一个函数，返回类型为int
我们看看下面两个代码：
(*(void (*)())0)(); // 代码1
void (*signal(int , void(*)(int)))(int) // 代码2
上述代码中：
代码1：可把0当做一个函数的地址，把0直接强制转换成一个void(*)()的函数指针，然后去调用0地址处的函数。
代码2：是一次函数声明，声明的函数叫signal，signal函数的第一个参数是int类型，第二个参数是一个函数指针类型，该函数指针指向的函数参数是int类型，返回类型是void。signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void。
五、函数指针数组
函数指针数组是多个函数指针放在数组里
可写成：
int(*pfArr[4])(int int);
函数指针数组的用途是转移表。
举个例子（计算器）：
#include <stdio.h>
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 x = 0;
int y = 0;
int input = 0;
int ret = 0;
int (*pfArr[5])(int, int) = { 0,Add,Sub,Mul,Div };
do
{
printf("请选择：");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入两个数字：");
scanf("%d %d", &x, &y);
ret = pfArr[input](x, y);
printf("%d\n", ret);
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}
运行效果：
六、指向函数指针数组的指针
是一个指针，指针指向的是一个数组，数组元素都是函数指针
举个例子：
int(*pf)(int int); // 函数指针
int (*pfArr[4])(int int); // 函数指针数组
int (*(*ptr)[4])(int int) = &pfArr; // 指向函数指针数组的指针
七、回调函数
回调函数就是一个通过函数指针调用的函数。把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数是，就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生是由另一方调用，用于对该事件或条件进行相应。
qsort函数的参数中就有一个函数指针，这个函数指针就是一个回调函数。
详解qsort函数
加深对指针的理解，可以看看：
指针的几个笔试题