那些年与指针的情仇（二）—二级指针&&指针与数组的那点事&&函数指针

关注小庄 顿顿解馋(｡･∀･)ﾉﾞ

欢迎回到我们的大型纪录片《那些年与指针的爱恨情仇》，在本篇博客中我们将继续了解指针的小秘密：二级指针，指针与数组的关系以及函数指针。请放心食用！

文章目录

• 一. 二级指针
• 二. 数组与指针的那点事儿
• • 1.🏠 数组名的理解
  • • 1.1 数组名本质理解
    • 1.2 sizeof数组名和取地址数组名
  • 2. 🏠 指针数组
  • 3.🏠 字符串常量
  • 4.🏠 数组指针
  • 5.🏠 数组传参
• 三. 函数指针

一. 二级指针

前面我们讲到了指针变量是个存储指针(地址)的变量，我们知道变量在创建的时候操作系统会给他分配内存空间同时给他编号（地址），那么指针变量的指针(地址)能否被存储呢？这里就引入我们二级指针的概念了

二级指针：存储指针变量地址的指针

*在上面表格中pp变量其实就是对应的二级指针，我们可以通过双重解引用pp来找到a,*pp = p, *(*pp)=a

注：二级指针类型定义时的*理解逻辑可以类比我们之前理解指针变量类型的定义，二级指针变量前的*说明这是个指针(存储地址的小子)，而前面的int*说明它指向的对象是int *类型的，他的变量类型是int **

二. 数组与指针的那点事儿

1.🏠 数组名的理解

1.1 数组名本质理解

int arr[10] = {1,2,3,4,6,7,8,9,10};
printf("&arr[0] = %p\n", &arr[0]);
printf("arr = %p\n", arr);

输出结果
&arr[0] = 004F9CC
arr = 004F9CC

这里我们可以得出数组名本质是首元素的地址，明白这个后我们以后访问数组就可以用指针的方式le

int arr[10]={1,23,4,5,6,7,8,9,10};
int* p = arr;
for(int i = 0;i < 10;i++)
{
   printf("%d ",*(p+i));
}//p+i指针加减法顺藤摸瓜到下个元素
//

延伸：*此时p与arr等价->arr[i] = *(p+i）= *(arr+i) *

那是否所有情况下都是这个样子呢？嘿嘿，我们看下面的代码

1.2 sizeof数组名和取地址数组名

Sizeof数组名

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d\n", sizeof(arr));

输出结果 ： 40

看到这里有同学会疑惑，数组名本质不是首元素地址吗？

小庄如是说：没错，但是这是一种特殊情况也就是特例，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩，单位是字节

&数组名

//代码1
int arr[10] = {1,2,3,4,5,6,78,9,10};
printf("%p\n",&arr[0]);
printf("%p\n",&arr);
printf("%p\n",arr);
//代码2
printf("&arr[0]+1 = %p\n", &arr[0]+1);
printf("arr+1 = %p\n", arr+1);
printf("&arr+1 = %p\n", &arr+1);

代码1输出结果：
0x004FC550 //&arr[0]
0x004FC550 //&arr
0x004FC550 //arr
代码2输出结果：
0077F824 //&arr[0] +1
0077F824 //arr+1
0077F848 //&arr+1

我们可以发现代码1输出结果相同，代码2就出现不同了其中&arr[0]和arr的结果相同这就再次验证了数组名的本质是首元素的地址，但对于&数组名+1，&arr和&arr+1相差40个字节，这就是因为&arr是数组的地址，+1操作是跳过整个数组的！

因此我们可以得出&数组名，这里的数组名表示整个数组，取出的是整个数组的地址，只不过数组都是从首个元素开始的。相当于你拿一箱水果只能一个一个搬，而比你壮的可以整箱搬起来

总结：对于数组名的运用，sizeof+数组名和&+数组名是特例表示整个数组地址，其他地方都是首元素地址

2. 🏠 指针数组

抛砖引玉：前面我们学习了数组的相关知识，整形数组是存储整型数据的数组，字符数组是存储字符型数据的数组… 那指针数组呢？

指针数组：存储指针的数组，数组每个元素都是来存储指针(地址)的，主体是数组.

• 语法形式

Datatype * arr[size]
这里的Datatype*指的是数组存储元素的类型，也就是arr是一个存储整型指针的数组，大小为size。

• 指针数组模拟二维数组

int arr1[] = {1,2,3,4,5};
int arr2[] = {6,7,8,9,10};
int arr3[] = {11,12,13,14,15};
int* arr[3] = {arr1,arr2,arr3};
int i,j;
for(i=0;i<3;i++)
{
   for(j=0;j<5;j++)
   {
   printf("%d ",arr[i][j]);
   }
   printf("\n");
}
//我们取每个整形数组首元素地址存储到指针数组中，就可以依靠这个首元素地址顺藤摸瓜到整个数组
//从而打印出每行实现二维数组的效果

延伸：arr[i][j] = * (*(arr+i)+j) ，arr[i]相当于是数组名，以每行为一个元素。

3.🏠 字符串常量

字符串我们学过下面两种表达式

1  char arr1[5] = "good";
2  char arr2[5] = {'g','o','o','d','\0'};

还有另外一种

const char* p = "good";

这里const修饰在*的前面说明p指向内容不可变，我们这时称这个字符串为常量字符串，这里是否表示把整个字符串放进p指针呢？不是的，这里意思是把字符串首元素地址放进p里，我们来段代码测试下。

char * p = "hello"
printf("%s",p);
printf("%c",*p);

输出结果为hello h，也就是说字符串打印是通过首地址来找到位置打印的跟字符数组类似

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"

输出结果：
str1 and str2 are not same
str1 and str2 are same

结论：1.c语言会把常量字符串存储到单独的一个内存区域，几个指针指向同一个字符串时指向的是同一块内存空间2.用他们初始化不同数组会开辟不同相独立的内存空间。

4.🏠 数组指针

抛砖引玉：整形指针是指向整形数据的指针，字符型指针是指向字符型的指针…那数组指针呢？

数组指针：指向对象为数组的指针，也就是存储的数组的地址

• 数组指针变量

1 int (*p)[10];

解释：这里的先与p结合表示p是个指针变量(存地址的小子)，p指向的是一个大小为10存储元素为整形数据的数组，指针类型为int()[10]
注：【】的优先级高于*，所以要加上（）来让*与p先结合表示他是个指针变量

• 数组指针变量初始化

int(*p)[10] = &arr; //取地址数组名取的是整个数组地址

5.🏠 数组传参

• 一维数组传参

void test(int arr[])
{
int sz2 = sizeof(arr)/sizeof(arr[0]);
printf("sz2 = %d\n", sz2);
}
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int sz1 = sizeof(arr)/sizeof(arr[0]);
printf("sz1 = %d\n", sz1);
test(arr);
return 0;
}

输出结果 sz1 = 10 sz2 = 1;

这里我们可以看到在函数内部和外部求数组长度得出的结果是不同的，原因就是数组传参时传的是数组名，也就是说数组传参本质上传的是首元素地址，此时函数内部sizeof(arr) == sizeof(arr[0]),因此我们不能在函数内部求数组长度

明白一维数组传参本质我们可以这样传数组

void test(int* p);

总结：一维数组传参可以写成数组的形式也可以写成指针的形式

• 二维数组传参

类比一维数组传参的本质 二维数组传参传的也是首元素地址，那二维数组的首元素是什么？

我们知道二维数组是一维数组的数组，也就是说二维数组的第一行元素就是它的首元素！那第一行元素地址怎么表示呢？这就与我们之前的数组指针串联起来了，也就是int(*p)[size];

void test(int arr[3][5]);
void test(int(*p)[5]);

总结：二维数组传参传的是第一行一维数组的地址，传参既可以写成二维数组的形式也可以写成数组指针的形式。

三. 函数指针

• 函数指针变量

经过前面的类比我们不难得出：
函数指针变量：存储函数地址的指针变量

函数是否有地址呢？我们写代码测试下

void test()
{
printf("hehe\n");
}
int main()
{
printf("test: %p\n", test);
printf("&test: %p\n", &test);
return 0;
}

输出结果
test: 005913CA
&test: 005913CA

所以函数是有地址的，函数名就是函数的地址,当然也可以通过 &函数名的方式获得函数的地址
延伸：函数指针调用(*p)(x,y)，由于函数名等价于&函数名，故函数指针调用也可以p(x,y)

• 函数指针变量的创建

int (*pf3) (int x, int y)；
//函数指针类型为 int(*)(int x ,int y)

解释：这里的*表示pf3是个指针变量用来存储指针，前面的int表示指向函数的返回值是int,后面的(int x,int y)表示的是指向函数参数的类型和个数(参数变量名可写可不写），可以类型数组指针变量的定义

• 函数指针数组

类比指针数组，把几个函数的地址存到一个数组，那这个数组就叫函数指针数组

那函数指针数组如何定义呢？

int (*parr1[3])();

数组特征是【】在函数指针变量基础上加上【】让parr1先与【】结合就是数组了，数组存储元素的类型为int(*)()

• typedef重新定义

typedef int(*parr_t)[5]; //新的类型名必须在*的右边
typedef void(*pfun_t)(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;
int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf(" 0:exit \n");
printf("*************************\n");
printf( "请选择：" );
scanf("%d", &input);
if ((input <= 4 && input >= 1))
{
printf( "输⼊操作数：" );
scanf( "%d %d", &x, &y);
ret = (*p[input])(x, y);
printf( "ret = %d\n", ret);
}
else if(input == 0)
{
printf("退出计算器\n");
}
else
{
printf( "输⼊有误\n" );
}
}while (input);
return 0;
}

这里将函数数组作为一个跳板将函数们放进一个表中方便使用，这里的函数指针数组就叫转移表

本次分享到这就结束了，喜欢的话给小庄三连吧！