【c语言】深入理解指针2

一、指针数组

指针数组到底是指针还是数组呢？

整型数组 int arr[] : 存放整型的数组；
字符数组 char arr[] : 存放字符的数组；
可以类比得到：
指针数组 int* arr[] : 存放指针的数组.

因此，指针数组本质上是数组，数组中的每个元素都存放的是地址(指针)，每个元素的类型为指针类型.

示例：下方代码中
parr先和 [ ] 结合，因此它是一个数组，这个数组有3个元素，每个元素的类型为int*

int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 1,2,3,4,5 };
int arr3[5] = { 1,2,3,4,5 };
int* parr[3] = {arr1,arr2,arr3};

将数组名去掉就可以看出它的类型，即int* [3],也就是指针数组

指针数组模拟二维数组

int main()
{//创建三个整型数组int arr1[5] = { 1,2,3,4,5 };int arr2[5] = { 1,2,3,4,5 };int arr3[5] = { 1,2,3,4,5 };//由于数组名就是数组首元素地址，将每个数组名存放到指针数组parr中int* parr[3] = {arr1,arr2,arr3};int i = 0;for (i = 0;i < 3;i++)//遍历三个数组名{int j = 0;for (j = 0;j < 5;j++)//遍历每个数组{printf("%d ", parr[i][j]);}printf("\n");}return 0;
}

对 parr [ i ] [ j ] 进行解释：

1. parr [ i ] 访问的是parr中的元素，找到的是第 i 个数组名，指向一维整形数组.
   比如 parr [ 0 ]找到的是 arr1, parr [ 1 ]找到的是 arr2, parr [ 2 ]找到的是 arr3, 因此 parr [ 0 ] 就是arr1数组名,本质就是第一个数组首元素地址
2. parr [ i ] [ j ] 指向一维数组中的元素，找到的是第 i 个数组的第 j 个元素.
   比如parr [ 0 ] [ 0 ] == arr1 [ 0 ] == 1
3. arr1, arr2, arr3本质上是指针，因此可以存到指针数组 parr 中.
4. parr模拟的二维数组并非是真正的二维数组，因为二维数组在内存中是连续存放的.

二、数组指针

数组指针到底是数组还是指针呢？

整型指针 int* p = &a : p 是存放整型变量地址、指向整型变量的指针；
字符指针char* pc = 'c' : pc 是存放字符变量地址、指向字符变量的指针；
浮点型指针 float* pf = &f: pf 是存放浮点型变量地址、指向浮点型变量的指针；
数组指针：int (*p) [ 5 ] = &arr : p 是指向整型数组的指针.

因此，数组指针本质上是指针，是指向数组的指针，存放的是数组的地址
示例：

int arr[] = { 1,2,3 };
int (*p)[3] = &arr;

1. p先与*结合，说明p是一个指针变量，然后与 [ ] 结合，说明它指向的是一个数组，数组中有三个元素，每个元素的类型为 int
2. 数组指针的初始化：数组指针存的是数组的地址，因此将整个数组取地址赋值给数组指针就可以

指针数组与数组指针的区分：
指针数组是存放指针的数组，“指针”是定语，修饰“数组”
数组指针是指向数组的指针，“数组”是定语，修饰“指针”

二维数组传参的本质

int arr[3][5] = { { 1,2,3,4,5 }, {2,3,4,5,6},{3,4,5,6,7 } }

arr[3][5]可以看作是一个有三个元素的一维数组，每个元素是一个一维数组，第一个元素是{1，2，3，4，5}，第二个元素是{2，3，4，5，6}，第三个元素是{3，4，5，6，7}，因此，遵循数组名是数组首元素地址的原则，那么认为二维数组的数组名其实就是第一行数组的地址，数组的地址类型为数组指针，那么二维数组传参的本质传递的是第一行数组的地址，需要用数组指针类型来接收

用数组指针来打印二维数组

void print(int (*p)[5])
{int i = 0;for (i = 0;i < 3;i++){for (int j = 0;j < 5;j++){printf("%d ", *(*(p + i) + j));//也可以写成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);return 0;
}

p 是数组指针，p + i 得到的是第 i 行元素的地址，*( p + i ) 得到的是第 i 行元素的数组名，*( p + i ) + j 得到的是第 i 行第 j 个元素的地址，再进行解引用就得到该元素

有人会问，p + i 是地址，*( p + i ) 得到的应该是数据，*( p + i ) + j得到的还是数字，*(*( p + i ) + j)就是对数字进行解引用，没有意义了.

实际上 p + i 是二维数组中第 i 行数组的地址，那么 p + 0 == p == arr [ 0 ], 以第一行数组为例，第一行数组是一维数组，arr [ 0 ] [ j ] 得到的是第一行数组第 j 个元素，那么arr [ 0 ]本质上就是第一行数组的数组名，也就是第一行数组首元素 1 的地址. 因此*（p + i）实际得到的是第 i 行的数组名，本质还是地址，想得到 i 行 j 列 这个元素需要 *(*(p + i) + j).

二维数组在想象中是以行和列形式存在的，但是在内存中的存储是连续的, 因此只需要知道首元素地址就可以连续访问

当然，二维数组传参，形参部分也可以写成二维数组（不能省略列），也可以写成数组指针形式.

三、字符指针变量

char* a = "abcdef";

其中，a是一个字符指针，存放的是字符串第一个字符的地址，并不是整个字符串的地址，并且该字符串为常量字符串，不能被改变，因此严谨来说应该在前加上const

const char* a = "abcdef";

示例：

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");elseprintf("str1 and str2 are not same\n");if (str3 == str4)printf("str3 and str4 are same\n");elseprintf("str3 and str4 are not same\n");

1. str3 和 str4 是两个相同的常量字符串， 在内存中只会开辟一块内存空间，不同的指针指向相同的常量字符串的时候，指向的是同一块内存空间，因此 str3 和 str4 是相同的
2. 用相同的常量字符串去初始化两个字符数组，内存会为两个数组单独开辟两个内存空间，因此str1和str2是不同的，他们分别指向两个不同的地址

四、函数指针变量

函数指针：指向函数的指针，存放的是函数的地址.
首先了解什么是函数的地址：

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

可以看出，函数名 test 和 &test 的地址是一样的，因此函数名就表示函数的地址，想存储函数的地址，就需要函数指针变量

函数指针的初始化：

int Add(int x, int y)
{return x + y;
}
int (*pf1)(int, int) = Add;
int (*pf2)(int, int) = &Add;

Add是一个函数，pf1 (pf2) 先与*结合，表明其是一个指针，然后与后面的（ ）结合，表明其指向的是一个函数，函数内部的参数有两个，分别都是 int 类型，函数的返回类型是 int 型.

去掉变量名pf1，就可以看出他的类型是 int ( * ) ( int , int )函数指针类型

4.1. 函数指针的应用

用函数指针实现两个数相加：

可以看出，上述三种方法都可以实现Add函数的调用

1. 直接用函数名调用函数.
2. 利用函数指针 pf 取得Add函数的地址，然后对其解引用*pf得到函数名，再进行调用.
3. 直接用函数指针pf进行调用.
   总结：函数名Add实际就是函数的地址，函数指针pf也是函数的地址，函数名直接调用函数就相当于用地址调用函数，那么直接用pf调用，不解引用也是可以的

比如：

实际上可以看出：
005513CF为函数Add的地址
函数指针pf，*pf得到的都是005513CF，即函数Add的地址，因此利用函数指针调用函数的时候可以不用解引用，直接进行调用

4.2 两端有趣的代码

1.第一段代码

(*(void (*)())0)();

从内部向外看

1. 黄色部分void ( * ) ( )，表明类型为函数指针类型
2. 蓝色括号 ( ) 0，表示将整型 0 强制类型转换成函数指针类型，得到的是一个地址 00000000，意味着我们假设0地址处放着无参，返回类型为void的函数
3. 绿色括号内部是对其进行解引用，得到的是该地址处的函数名
4. 右侧黑色括号表示调用这个函数
   因此调用的是0地址处的函数，函数的返回类型为void，函数参数为无参

2. 第二段代码

void (*signal(int, void(*)(int)))(int);

signal，先与后面接的蓝色括号结合，表明它指向一个函数，说明它是一个函数名，该函数内部有两个参数，类型分别是 整型int 和 函数指针类型 void(*)(int)，然后将函数名和函数参数去掉可以得到：

函数还缺一个返回类型，因此该函数的返回类型为函数指针类型

将这段代码改写以下就可以更清楚看到：

1. signal 是函数名，指向的函数内部有两个参数，参数类型分别是整型和函数指针类型，该函数的返回类型为函数指针类型
2. 这种写法只是便于分析，在编译器中这种写法是不允许的，只能写成第一种形式

4.3. typedef关键字

4.3.1 typedef 的使用

如果类型写起来太复杂，我们可以将其重新定义，进行简化，比如
将unsigned int 重命名为uint

typedef unsigned int uint;

对于指针数组来说，正确的重命名为 parr_t 的方式是，parr_t 必须在 * 的右边

typedef int(*parr_t)[5] 

同样对于函数指针,将其重命名为pfun_t，必须放在*的右边

typedef void(*pfun_t)(int,void(*)())//新的类型名必须放在*的右边 
pfun_t signal(int，pfun_t);//对代码进行简化

4.3.2. typedef与#define对比

typedef int* ptr_t;
ptr_t p1,p2;

将 int*类型重命名为 ptr_t ，p1, p2均为指针变量

#define PTR_t int*
PTR_t p1,p2;

将PTR_t 定义为int* 类型，那么p1为指针变量，p2为整型变量 ，因为替换之后为： int* p1, p2,是一个逗号表达式，*只会与p1结合

五、函数指针数组

函数指针数组：存放函数指针的数组，本质是一个数组，用来存放函数指针变量.
函数指针数组的定义：

int (* parr [ 3 ] ) ( )；

parr先与[ ]结合，表明它是一个数组，该数组有3个元素，每个元素的类型为函数指针类型 int ( * ) ( )

函数指针数组的应用

转移表的实现：
实现一个具有加减乘除的计算器：

void menu()
{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 a = 0;int b = 0;int input = 0;int ret = 0;do {menu();printf("请选择:");scanf_s("%d", &input);switch (input){case 1:printf("请输入两个参数：");scanf_s("%d %d", &a, &b);ret = Add(a, b);printf("%d \n", ret);break;case 2:printf("请输入两个参数：");scanf_s("%d %d", &a, &b);ret = Sub(a, b);printf("%d \n", ret);break;case 3:printf("请输入两个参数：");scanf_s("%d %d", &a, &b);ret = Mul(a, b);printf("%d \n", ret);case 4:printf("请输入两个参数：");scanf_s("%d %d", &a, &b);ret = Div(a, b);printf("%d \n", ret);break;case 0:printf("退出\n");break;default:printf("请重新输入：");break;}} while (input);return 0;
}

通过选择1、2、3、4实现计算器的运算，但是这种方法有一个缺点，每一个case下面几乎都是相同的功能，唯独不同的就是进行函数的调用，因此我们应该想办法将这一重复的功能封装成一个函数去实现

利用函数指针数组实现计算器：

void menu()
{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 a = 0;int b = 0;int input = 0;int ret = 0;int (*pf[5])(int, int) = { 0,Add,Sub,Mul,Div };do {menu();printf("请选择:");scanf_s("%d", &input);if (input <= 4 && input >= 1){printf("请输入操作数：");scanf_s("%d %d", &a, &b);ret = pf[input](a,b);printf("%d\n", ret);}else if(input==0){printf("退出\n");}else{printf("重新输入");}} while (input);return 0;
}

利用函数指针实现转移表：

将重复的功能封装到calc函数中实现，通过函数指针调用加减乘除函数
main是主调函数，calc函数是被调函数，具体实现加减乘除功能的函数为回调函数

void menu()
{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;
}
void calc(int (*pf)(int, int))
{int a, b;printf("请输入两个参数：");scanf_s("%d %d", &a, &b);int ret = pf(a, b);printf("%d \n", ret);
}
int main()
{int a = 0;int b = 0;int input = 0;int ret = 0;do {menu();printf("请选择:");scanf_s("%d", &input);switch (input){case 1:calc(Add);break;case 2:calc(Sub);break;case 3:calc(Mul);case 4:calc(Div);break;case 0:printf("退出\n");break;default:printf("请重新输入：");break;}} while (input);return 0;
}