提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档
指针进阶(探讨指针的高级主题)
前言
我们知道指针的概念:
- 指针就是个变量,用来存放地址,地址唯一标识一块内存空间。
- 指针的大小是固定的4/8个字节(32位平台/64位平台)。
- 指针是有类型,指针的类型决定了指针的±整数的步长,指针解引用操作的时候的权限。
- 指针的运算
一、数组指针
对比指针数组,我们举一个例子
int *p1[10];
int (*p2)[10];
//p1, p2分别是什么
int (*p)[10]; 解释:p先和*结合,说明p是一个指针变量,然后指着指向的是一个大小为10个整型的数组。所以p是一个 指针,指向一个数组,叫数组指针。 这里要注意:[]的优先级要高于*号的,所以必须加上()来保证p先和*结合。 |
二、指针数组的传参
我们知道一维数组传参时,可以直接传其首元素地址,那么当同样的问题拓展到二维数组的时候,答案还是一样吗?
答案是肯定的的,二维数组传参还是它的首元素地址,类比一维数组,二维数组首元素指的是它的第一行的整个数组地址。
所以我们 传入的参数应该是第一行的地址,下面有几个例子,我们来判断一下它们是否可行:
#include<stdio.h>
void test(int arr[3][5])//ok?
{}
void test(int arr[][])//ok?
{}
void test(int arr[][5])//ok?
{}
void test(int* arr)//ok?
{}
void test(int* arr[5])//ok?
{}
void test(int(*arr)[5])//ok?
{}
void test(int** arr)//ok?
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
}
①int arr[3][5]:传入参数为一模一样的数组形式,可行。
②int arr[][]:列不能省略,不可行。
③int arr[][5]:参考②,可行。
④int* arr:这里传的arr是一级指针,而我们要传的参数是二维数组第一行的地址,是一个数组的地址,一级指针类比一维数组,传入的是首元素的地址,不可行。
⑤int *arr[5]:这里传的是指针数组,不是我们要的指针,不可行。
⑥int(*arr)[5]:传的是数组指针,指向的数组为五个int类型的数组,可行。
⑦传的是二级指针,不可行。
三、函数指针
首先,我们提出疑问,函数也有地址吗?
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
运行结果如下:
说明函数的确有地址,那么函数指针如何表示呢?
举个例子
void test()
{
printf("hehe\n");
}
void (*pfun1)();
圆括号里的*说明pfun1是指针,void()()为pfun1指向的类型,指向void函数,其参数也为void。
四、函数指针数组
同理,函数指针也有数组。
其表示方式如下:
int (*parr1[10])();
parr1先与[]结合,说明是数组,数组每个元素是int(*)()。
函数指针数组的运用
转移表(以计算器为例)
仅用分支循环实现
#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");
breark;
default:
printf( "选择错误\n" );
break;
}
} while (input);
return 0;
}
可以看到,每一个case都有重复的步骤,看起来很啰嗦。
通过函数指针数组来实现:
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;
}
五、经典指针笔试题
1.笔试题一
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少?
//已知,结构体Test类型的变量大小是20个字节
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}
//程序的结果是什么?
①第一个打印结果:p作为结构体类型指针+1,即跳过20个字节
②第二个打印结果:p被强制转换为整型,整形加1,打印结果就是p的原先地址数值加1
③第三个打印结果:怕被强制类型转换为int*,加1跳过四个字节
运行结果如下:
2.笔试题二
int main()
{
int a[4] = { 1, 2, 3, 4 };
int *ptr1 = (int *)(&a + 1);
int *ptr2 = (int *)((int)a + 1);
printf( "%x,%x", ptr1[-1], *ptr2);
return 0;
}
ptr1[-1]<===>*(ptr1-1),即4
假设在小端存储,则ptr2指向的位置如下:
如图蓝色为ptr2指向的4个字节,转换成十六进制即为2 00 00 00(%x打印时,多余的0会省略,如上02省略成2)
3.笔试题三
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
int *p;
p = a[0];
printf( "%d", p[0]);
return 0;
}
该题易错点在于逗号表达式,a应为:
p指向第一行首元素地址,p[0]打印结果为1
4.笔试题四
int main()
{
int a[5][5];
int(*p)[4];
p = a;
printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}
指向位置如图下所示:
%p打印结果相当于数值以十六进制形式打印,即-4的十六进制形式(打印的是-4存储的值,是其补码形式)
%d打印的是之间相差的元素个数
打印结果如下:
5.笔试题五
int main()
{
int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int *ptr1 = (int *)(&aa + 1);
int *ptr2 = (int *)(*(aa + 1));
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
return 0;
}
&aa+1跳过整个二维数组个字节大小,aa+1等价&aa[1],为第二行数组的地址
打印结果如下:
6.笔试题六
int main()
{
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char**cp[] = {c+3,c+2,c+1,c};
char***cpp = cp;
printf("%s\n", **++cpp);
printf("%s\n", *--*++cpp+3);
printf("%s\n", *cpp[-2]+3);
printf("%s\n", cpp[-1][-1]+1);
return 0;
}
废话不多说,咱上图解释:
①**++cpp得到c[2],打印结果即为POINT
② 先后顺序为(*- -(++cpp))+3,为ER
③cpp[-2]+3等价于*(*(cpp-2))+3,打印ST
④cpp[-1][-1]+1等价于*(*(cpp-1)-1),打印EW
打印结果如下:
总结
不论是数组指针,数组指针数组还是函数指针,函数指针数组。都可以类比,只要找到变量先于*结合还是与[]结合,若与*结合,那么它就是指针,然后在心里询问它指向的类型是什么?同理,如果与[]结果,他就是数组,数组的元素类型是什么?像洋葱一样一次剥开即可。