指针进阶
1.字符指针
- 字符指针是指向字符或者字符串的指针。
char a = 'a';
char *pa = &a;
const char *pb = "abc";
pa和pa都是字符指针，pa存放a的地址，pb存放"abc"中a的地址，即字符串首元素的地址。"abc"是常量字符串，常量字符串的内容不能修改，所以常在指针变量前+const。
- 例子
#include <stdio.h>
int main()
{
char str1[] = "abc";
char str2[] = "abc";
const char *str3 = "abc";
const char *str4 = "abc";
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;
}
答案
str1 and str2 are not same
str3 and str4 are same
分析
str1和str2都是数组，在内存中创建的两片内存空间，这两片空间存放的都是abc，数组名指向数组首元素，两片空间的首元素地址不同，所以str1不等于str2。
str3和str4是字符指针，指向常量字符串"abc"。常量字符串不可修改，内存没必要存放多份不可修改的内容，公用一份即可，所以str3和str4指向的空间相同，所以str3等于str4。
2.指针数组
存放指针的数组
const char *arr[4] = {"abc","def","hij","klm"};
指针数组以前学过，这里就不赘述了。
3.数组指针
- 概念
字符指针——存放字符地址的指针，指向字符的指针
整形指针——存放整形地址的指针，指向整形的指针
数组指针——存放数组地址的指针，指向数组的指针 - 表示
char a = 'a';
char* pa = &a;//a是变量名，*表示a是指针，char表示a指向的类型是字符
int arr[10];
int (*pi)[10] = &arr;//pi是变量名，*表示pi是指针，int [10]表示pi指向的类型是数组，
//int表示pi指向的数组类型是整形，[10]表示pi指向的数组有10个元素。
//注意：不能去掉括号，否则pi与[10]结合，变成指针数组。
- &数组名和数组名的区别
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
printf("%p\n",arr);
printf("%p\n",&arr);
printf("%p\n",&arr[0]);
我们发现arr、&arr、&arr[0]都表示数组首元素的地址，很难发现它们之间的区别。
printf("%p\n",arr+1);
printf("%p\n",&arr+1);
printf("%p\n",&arr[0]+1);
arr+1：arr是数组名，数组元素类型是int，+1就跳过1个整形，地址加上4个字节。类型是int*，是整形指针。
&arr[0]+1：类型是int*，+1跳过一个整形（4个字节）。
&arr+1：用&arr+1减去&arr，再转换成十进制，刚好是40个字节，即数组的大小，所以+1跳过整个数组。类型是int（*）[10]。
总结数组名是数组首元素的地址，&数组名是数组的地址，数组首元素的地址和数组的地址从值的角度是一样的，但意义不一样。
- 数组指针的使用
一般用于二维数组
void print(int arr[3][4],int r,int c)
{
for(int i = 0;i<r;i++)
{
for(int j = 0;j<c;j++)
{
printf("%d ",arr[i][j]);
}
printf("\n");
}
}
void print2(int(*pa)[4],int r,int c)
{
for(int i = 0;i<r;i++)
{
for(int j = 0;j<c;j++)
{
printf("%d ",*(*(pa+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);//常规做法
print2(arr,3,4);//用数组指针完成
return 0 ;
}
print1和print2都是打印二维数组。但为什么print2实参arr用数组指针接收？二维数组的数组名是否还是表示首元素的地址？如图
int(*pa)[10] = &arr，那么 * (pa) = arr，所以( *（pa+i）+j) == * (pa+i)[j] == pa[i][j]。
此外，二维数组的首元素地址是&arr[0][0]。
- 练习
int arr[5];//整形数组，有5个元素
int*parr1[10];//parr1和[]结合，说明其是数组，数组的每个元素类型是int*。
int(*parr2)[10];//parr2和*结合，说明其是指针，指针指向的类型是int[10]。
int(*parr3[10])[5];//parr3和[]结合，说明其是数组，数组有10个元素，
//每个元素的类型是int(*)[5]，即数组指针。
4.数组参数和指针参数
当函数实参是数组名和指针时，形参可以分别用什么接收？两者的形参又有什么区别？
4.1一维数组传参
void test1(int arr1[]/int arr1[10]/int*arr1)
{
;
}
void test2(int*arr2[]/int*arr2[10]/int**arr2)//数组名表示首元素的地址，首元素是一级指针，
{ //其地址用二级指针表示
;
}
int main()
{
int arr1[10] = {0};
int*arr2[10] = {0};
test1(arr1);
test2(arr2);
return 0;
}
4.2二维数组传参
void test(int arr[3][5]/int arr[][5]/int(*arr)[5])
{ //二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
;
}
int main()
{
int arr[3][5] = {0};
test(arr);
return 0;
}
4.3一级指针传参
void print(int*p,int sz)
{
;
}
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int*p = arr;
print(p,10);
return 0 ;
}
4.4二级指针传参
void test(int**p)
{
;
}
int main()
{
int n = 10;
int*p = &n;
int**pp = &p;
int *arr[10] = {0};
test(pp);
test(&p);
test(arr);
return 0 ;
}
5.函数指针
- 概念
数组指针——指向数组的指针
函数指针——指向函数的指针 - 表示
int Add(int x,int y)
{
return x+y;
}
int main()
{
int a = 1;
int b= 2;
int(*pa)(int,int) = &Add;
//*与pa结合表示pa是指针
//前面的int表示指针指向函数的返回值类型
//(int,int)表示指针指向函数的参数的类型
int(*pb)(int,int) = Add;
//&函数名和函数名都表示函数的地址，类似于数组
return 0;
}
- 调用函数
int ret = (*pa)(2,3);
printf("%d",ret);
答案5
因为pa = &Add和pa = Add效果相同，所以(*pa)(2,3) == Add(2,3) == pa(2,3)。
- 练习（出自《C陷阱与缺陷》）
(*(void(*)())0)();
(void(*)())0表示把int类型的0强制类型转换成函数指针类型，前面的 * 表示对函数指针进行解引用，后面()表示无参。
总结该代码是一次函数调用，调用0地址的函数。首先代码中将0强制类型转换为void( * )()的函数指针，然后去调用0地址处的函数。
void (*signal(int,void(*)(int)))(int)
遇到这种题先找特殊，即变量名或者0。signal与void( * )(int)结合表示signal是函数，void( * )(int)是signal函数的返回类型，(int,void( * )(int))是函数参数的类型。
总结该代码是一次函数的声明，声明的函数名叫signal，函数参数有二，一是int类型，
二是函数指针类型，该函数指针指向的函数参数是int类型，返回值类型是void，signal函数的返回值类型是一个函数指针，指向的函数的参数是int类型，返回值类型是void。
优化我们发现很难找到函数的返回类型而且打字非常繁琐，所以我们可以对void(*)(int)进行重命名，简化函数声明。
typedef void(*)(int) pf_t;//错误的
typedef void(*pf_t)(int);//正确的
pf_t signal(int,pf_t);
6.函数指针数组
- 概念
int my_strlen(const char*arr)
{
;
}
int main()
{
char*arr[10];//存放字符指针的数组
int(*pf[5])(const char*);//pf是函数指针数组
//pf与[]结合表示pf是数组，int(*)(const char*)表示数组元素类型
pf[0] = &my_strlen;
return 0;
}
- 应用（整数加减乘除的计算器）
void menu()
{
printf("**************************************\n");
printf("********** 1.Add 2.Sub **********\n");
printf("********** 3.Mul 4.Div **********\n");
printf("********** 0.Exit **********\n");
}
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[5])(int, int) = {0,Add,Sub,Mul,Div};
int input = 0;
do
{
menu();
printf("请选择:>\n");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("请输入两个操作数\n");
int x = 0;
int y = 0;
scanf("%d%d", &x, &y);
int ret = arr[input](x, y);
printf("结果为:>%d\n", ret);
}
else if (input == 0)
{
printf("退出游戏\n");
break;
}
else
{
printf("选择错误，请重新选择\n");
}
} while (input);
return 0;
}
优点
（1）. 用函数指针存放上述函数的地址，因为它们的返回值和参数类型相同。
（2）.使用函数指针数组不会像用switch那么冗长、比较简短。
7.指向函数指针数组的指针
int(*pf[5])(int,int);
int(*(*ppf)[5])(int,int);
( * )与ppf结合表示ppf是指针， ( * ppf)与[5]结合表示ppf指向一个数组，int(*)(int,int)表示指向的数组的每个元素的类型是函数指针。
8.回调函数
- 定义
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。 - 例子
int Add(int x, int y)
{
return x + y;
}
int test(int(*p)(int, int))
{
int x;
int y;
scanf("%d%d", &x, &y);
return p(x, y);
}
int main()
{
int ret = test(Add);
printf("%d", ret);
return 0;
}
没有直接调用Add函数，而是把Add函数的地址传过去，用函数指针接收，然后在另一个函数用函数指针调用Add，Add函数就是回调函数。
600
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
