指针进阶（探讨指针的高级主题）

犄一犄犄角旮旯

已于 2022-01-27 11:46:26 修改

阅读量971

点赞数

分类专栏： C语言文章标签：排序算法数据结构算法

于 2022-01-23 12:31:02 首次发布

本文链接：https://blog.csdn.net/weixin_52265481/article/details/122647526

版权

C语言专栏收录该内容

8 篇文章

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

指针进阶（探讨指针的高级主题）

前言
一、数组指针
二、指针数组的传参
三、函数指针
四、函数指针数组
- 函数指针数组的运用
- - 转移表（以计算器为例）
五、经典指针笔试题
总结

前言

我们知道指针的概念：

指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
指针的大小是固定的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;
}