上篇我们讲到指针模拟二维数组，今天我们来继续学习更多类型的指针变量。
目录
1.字符指针变量
我们在一开始学习指针的时候，认识了一种指针变量类型char*，一般情况下，它的使用如下：
#include<stdio.h>
int main()
{
char c = 'c';
printf("%c\n", c);
char* pc = &c;
*pc = 'b';
printf("%c\n", *pc);
return 0;
}但是，char*类型的指针还有另一种使用方式：
#include<stdio.h>
int main()
{
const char* pc = "hello";
printf("%s\n", pc);
return 0;
}在该代码中，const char* pc=“hello”；，大家第一感觉是不是将字符串“hello”放在了指针变量pc中，但本质上其实是将“hello”的首字母的地址存放在了pc中。
另外，为什么这里要对字符串加上const修饰呢？
原因是：这里的字符串是常量字符串，是无法被修改的，所以使用const修饰，防止对字符串进行修改。
我们接下来看一道题来加深对常量字符串的认识：
#include <stdio.h>
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");
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和str2是两个数组，它们存放的内容都是”hello bit“，而str3和str4是两个常量字符串。
实际上输出的内容是：
str1 and str2 are not same 和 str3 and str4 are same
因为str1和str2是两个数组，数组在创建的时候会开辟空间，而数组名是数组首元素的地址，因为两个数组的地址不同，所以str1和str2不同。
至于str3和str4，C/C++会把常量字符串存储到单独的⼀个内存区域，因为二者都是常量字符串，都无法被修改，没必要使用两份空间来储存这一字符串，所以当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存，所以str3和str4都指向该常量字符串的首字母地址。
2.数组指针变量
在上一篇中末尾我们学到了指针数组，我们说指针数组是一个元素都是指针的数组。而我们今天要学习的数组指针，应该就是指针了。
那么数组指针的指针该指向哪里呢？是数组吗？
我们还是按照之前的类比，整形指针存放的是整形数据的地址，字符指针存放的是字符数据的地址，所以数组指针中的指针存放的应该就是数组的地址了。
大家可能要被绕懵了，那我们来学习一下指针数组和数组指针的区分：
int （*p1）[10];
int *P2[10];我们来看p1和p2，二者只有一个括号的区别，但含义却完全不同。
因为[ ]的优先级比*要高，所以对于p1来说，p1先与*结合，说明p1是指针，而该指针指向的内容是一个有10个int类型数据的数组。
对于p2来说，p2先与[ ]结合，说明p2是数组，数组的元素类型是int*类型。
2.1数组指针的初始化
了解了数组指针，那么数组指针应该怎么初始化呢？
数组指针是用来存放数组的地址的，要得到数组的地址，就要使用之前学到的&arr来取出数组arr的地址。
int arr[10]={0};
int (*p)[10]=&arr;我们将数组的地址存放在数组指针变量p中，int 是数组中元素的类型，[10] 是数组的元素个数，p 是数组指针变量的名字。
3.二维数组传参本质
我们之前学到了一维数组的传参本质是将数组的首元素地址传给函数，实际上传入的是指针。
那二维数组是怎样传参的呢？
我们先看一个之前写过的代码，遍历打印二维数组的元素：
#include<stdio.h>
void test(int a[3][5], int row, int col)
{
int i = 0, j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", a[i][j]);
}
printf("\n");
}
}
int main()
{
int a[3][5] = { {1,2,3,4,5},{2,3,4,5,6}, {3,4,5,6,7} };
test(a, 3, 5);
return 0;
}这里形参写成了指针形式，那么还有什么其他的写法吗？
我们回想一下之前学习二维数组的时候，我们说到可以将二维数组看成是一个元素都是一维数组的数组，那么二维数组的每一行都是一个一维数组。
若我们有一个二维数组如图所示，由于数组名是数组首元素地址，所以二维数组的数组名是第一行的地址，由于第一行是一维数组，而该一维数组有5个元素，所以第一行的地址类型为int (*)[5]，那么二维数组传参时实际上传入的也是地址，是第一行的地址，所以形参还可以写成指针形式，如下：
#include<stdio.h>
void test(int (*p)[5], int row, int col)
{
int i = 0, j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", *(*(p+i)+j));
}
printf("\n");
}
}
int main()
{
int a[3][5] = { {1,2,3,4,5},{2,3,4,5,6}, {3,4,5,6,7} };
test(a, 3, 5);
return 0;
}因为数组指针变量p是第一行的地址，所以p+i应该是第i行的地址，对p+i进行解引用，得到的是第i行的数组，再+j得到的是第i行第j列的元素的地址，再对其解引用就得到了第i行第j列的元素。
所以二维数组的传参，和一维数组相同，既可以写成数组形式，也可以写成指针形式。
4.函数指针变量
4.1函数指针变量的创建
接下来我们继续学习一个函数指针，通过类比，不难想出函数指针变量存放的是函数的地址，而通过函数的地址可以调用函数。
但是函数到底又没有地址呢？我们来看下面的代码：
通过对test的地址打印，可以看到函数是有地址的，并且函数函数名和&(函数名)代表的都是函数的地址。
而我们想将函数的地址存放起来，就要使用到函数指针变量，函数指针变量的创建与数组指针变量的创建十分相似。具体形式如下：
void test()
{
printf("haha\n");
}
void (*p1)()=test;
void (*p)()=&test;
int Add(int x,int y)
{
return x+y;
}
int (*p3)(int,int)=Add;
int (*p4)(int,int)=&Add;可以看出void和int都是函数的返回值类型，p1，2，3，4是函数指针变量的变量名，后面括号内的是函数的参数类型。
4.2函数指针变量的使用
可以同过函数指针来调用函数，代码如下：
#include<stdio.h>
int Add(int x, int y)
{
return x+y;
}
int main()
{
int (*p)(int, int) = Add;
printf("%d\n", p(3, 5));
printf("%d\n", (*p)(2, 3));
return 0;
}因为函数名和&(函数名)都代表函数的地址，所以对不对p进行解引用都可以得到函数的地址来调用函数。
下面我们来看两条代码，大家能分辨出这两个分别是什么指针吗？
(*(void (*)())0)();
void (*signal(int , void(*)(int)))(int);我们先看第一个，首先看内部的void (*)()，这应该是一个无参数，返回值为void类型的函数指针，而void (*)()是该函数指针的类型，所以这里是把0作为地址进行了强制类型转换，将int类型转为了函数指针类型，而外层是对函数指针变量的解引用，外层函数也是无参的。
接下来我们看第二个，看外层是一个函数指针，然后看内层，我们发现内部也有一个函数指针，难道一个函数指针是另一个函数指针的变量名吗？显然不是这样的，其实这里的函数signal有两个参数，一个是int类型的，另一个是函数指针类型，并且signal函数的返回值类型也是函数指针。我们换一种形式来写，应该是这样的：
void(*)(int) signal(int,void(*)(int));
这下是不是一下子清晰了呢，至于为什么写成题目里那样，我们稍后再说。
5.typedef关键字
学过了这么多指针变量，是不是感觉有些指针变量代码很长，写起来很费时间，那我们来学习一个关键字typedef：typedef是用来给类型重命名的，比如说对于unsigned int类型可以改为uint。
具体代码如下：
typedef unsigned int uint；
unsigned int a=3；
uint b=5；在修改了类型名后，可以使用新类型名，也可以继续使用原类型名。
指针类型也是可以被修改的，从最常见的指针写起：
typedef int* ptr_t;
但是对于函数指针和数组指针，二者的重命名有些不同
typedef int (*ptest_t)(int ,int );
typedef int (*parr_t)[5];对于这两个类型，修改后的类型名必须要写在*的右面。
对于上面的代码，进行重命名后，可以修改为
typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);6.函数指针数组
数组存放的类型相同的数据，上面学过了指针数组，经过类比，我们可以知道，函数指针数组是一个数组，数组元素类型是函数指针。
int (*parr1[3])()；因为[ ]的优先级比*要高，所以parr1先与[ ]结合，说明parr1是一个数组，那数组的元素类型是什么呢？答案是 int (*)()类型的函数指针。
有了函数指针数组，我们可以将类型相同的函数指针存放在数组中，方便调用。
7.转移表
函数指针数组的用途：转移表。
举例，计算器的实现。
比如说我们想实现一个可以对整形数据进行加减乘除运算的计算器，首先加减乘除四个函数的参数都是两个整形数据，返回值也是整形，那么这四个函数的类型相同，可以存放到一个函数指针数组中。
对计算器的实现如下：
#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;
}那么今天多种类型的指针变量的学习就到这里了，我们下次再见。
1038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
