文章目录
1 字符指针变量
我们知道指针类型有字符指针char* 类型，可以用char*来定义指针变量指向字符的地址。
那么肯定会有同学好奇，那怎么用指针变量和字符转建立起联系呢？
#include <stdio.h>
int main()
{
char* ptr = "abcdef";
return 0;
}
这段代码在最开始看的时候肯定很多人都不理解，ptr是指针变量，应该存放的是地址，为什么能够把字符串abcdef\0存起来呢，其实，像这样的常量字符串，放在表达式里时，它的值是首字符a的地址。
我们可以这样理解：
数组在内存中是连续存放的，数组名是数组首元素的地址，
字符串在内存中也是连续存放的，是一串连续的字符，在C语言中，字符串常量本身就是一个字符数组，以null结尾。所以类推整串字符的值就是字符串首元素的地址。
所以上面的代码就是把字符串首字符a的地址放在char*类型的指针变量ptr里。
可以通过代码验证：
#include <stdio.h>
int main()
{
char* ptr = "abcdef";
printf("%c", *ptr);
return 0;
}
常量字符串顾名思义它无法被修改，所以我们最好可以在类型前面加const修饰，使得字符串无法被修改，如果我们不小心修改了，编译器会提前报错提示，而不是等待程序运行了之后出问题了才报错。
#include <stdio.h>
int main()
{
const char* ptr = "abcdef";
printf("%c", *ptr);
return 0;
}
我们可以通过指针变量ptr来打印出整个字符串。
#include <stdio.h>
int main()
{
char* ptr = "abcdef";
printf("%s", ptr);
return 0;
}
注：C语言中的字符串以null字符（\0）结尾，printf函数会自动从指针指向的地址开始打印字符，直到遇到null字符为止。，所以在打印的时候不需要解引用。
练习：下列代码的输出是什么
#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字符串，数组名是数组首元素的地址，所以str1是第一块空间的h的地址，str2是第二块空间的h的地址，它们分配的是不同的空间，所以第一组输出str1 and str2 are not same。
其次是字符串str3和str4，它们都是指针变量，也存的是字符串首元素的地址，但是我们知道常量字符串是无法被修改的，所以一样的内容，只会占用同一块空间。str3和str4都指向同一块空间的h的地址，所以第二组输出的应该是str3 and str4 are same。
结果如图:
2 数组指针变量
2.1 数组指针变量的理解
我们依然可以用类比的方法来理解：
整形指针，是指向整形的指针，存放的是这个整形的地址，
例如int a = 10; int * p = &a;
指针变量p指向的就是变量a在内存中的地址，因为是指针，所以前面加一个 * ，又因为变量a是整形变量，所以p的类型是int *。
字符指针，是指向字符的指针，存放的是这个字符的地址，
例如char ch = ‘a’; int * p = &ch;
指针变量p指向的就是变量ch在内存中的地址，类型是char *。
经过类比可以得到：
数组指针，是指向数组的指针，存放的是这个数组的地址，不是数组首元素的地址
例如int arr[10] = { 0 }; int (* p) [10]= &arr;
首先 * p表示这是一个指针，[10]表示指针指向的数组有10个元素，int表示每个元素都是int类型的。
注意:
1.(不能写成int[10] *p = &arr)；因为语法不支持。
2.此时p的类型是去掉它本身，也就是 int (* ) [10]。
3.(* p一定要加括号括起来)，如果不加括号，那么就是int * p [10]= &arr；因为[]的优先级是1, * 的优先级是2。[]的优先级更高一些，所以编译器在运行时会先将p和[10]放在一起，会变成int * (p [10])= &arr；这是一个指针数组，是存放指针的数组，不是我们想要的数组指针，显然为了能够满足数组指针的条件，我们需要用优先级更高的()来把 * 和指针变量括起来，强调这是一个指针，然后再与[]结合，表示数组的元素的个数以及每个元素的类型。
2.2数组指针变量的使用
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int(*p)[10] = &arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", (*p)[i]);
}
return 0;
}
我们创建的指针变量 * p指向的是整个数组，存放的是整个数组的地址，所以我们先解引用，* p就相当于* (&arr)=arr;得到的是数组名，数组名加上数组内元素的下标，就能够访问对应的元素，所以我们在访问时可以写成
(*p)[i],访问数组下标为i的元素。
实际上一般写代码时不会这样使用，这样的代码只是方便我们理解知识，有了数组指针变量的知识，我们就能更好的理解二维数组传参的本质。
3 二维数组传参的本质
首先我们要清楚，二维数组也是数组，数组名也是数组首元素的地址。
#include <stdio.h>
void test(int arr[3][5], int r, int c)
{
int i = 0,j = 0;
for (i = 0; i < r; i++)
{
for (j = 0; j < c; j++)
{
printf("%d ", arr[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 } };
test(arr,3,5); //这里传递过去的其实是数组arr的首元素的地址
return 0;
}
要得到二维数组首元素的地址，首先我们要想清楚首地址是谁的地址。
二维数组的每一行是一维数组的形式，我们可以把这个一维数组看成二维数组的一个元素，这样上面的二维数组有3行就是有3个元素，二维数组传递的首元素的地址就是第一行的地址。
所以上面的代码形参部分可以修改成指针的形式：
#include <stdio.h>
//指针变量arr指向二维数组的第一行，存放第一行的地址，且第一行有5个元素
void test(int (*arr)[5], int r, int c)
{
int i = 0,j = 0;
for (i = 0; i < r; i++)
{
for (j = 0; j < c; j++)
{
printf("%d ", *( ( *(arr+i) )+j) );
//1.*(arr+i)指针指向第i行，解引用得到第i行的数组名，
//也就是第i行首元素的地址.*(arr+i)等价于arr[i]
//2.( *(arr+i) )+j)，得到第i行首元素的地址后，
//再通过+j访问一行中下标为j的元素的地址
//3.最后解引用，得到第i行，第j列地址的元素,
//最终的式子等价于arr[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 } };
test(arr,3,5);
return 0;
}
二维数组在内存中是连续存放的，通过数组名加[]的形式可以访问对应下标的数组元素，我们一般访问二维数组的元素时用的是arr[i][j]，访问第i行第j列的元素，如果把二维数组的每一行看成一个一维数组，通过一维数组的数组名加上下标就能找到对应的元素，通过下图，我们可以将arr[0]理解成第一行的数组名，将arr[1]理解成第二行的数组名，将arr[2]理解成第三行的数组名，数目名相当于首元素的地址，我们可以通过下标j访问元素。
总结：
1.二维数组是一维数组的数组，每一行可以看成二维数组的一个元素
2.二维数组作为参数传递时，传递的是数组首元素的地址，也就是第一行的地址
4 函数指针变量
4.1函数指针变量的理解
我们知道，数组指针，是指向数组的指针，存放的是数组的地址。
类推我们可以得到：函数指针，是指向函数的指针，存放的是函数的地址。
数组名是数组首元素的地址，那函数没有首元素，函数名的地址是什么呢？
我们可以通过代码来观察一下：
#include <stdio.h>
void hanshu()
{
}
int main()
{
printf("%p\n", &hanshu);
printf("%p\n", hanshu);
return 0;
}
可以发现，&函数名和函数名都是函数的地址。
如果我们想要把函数的地址存起来，就需要创建函数指针变量。
我们可以仿照数组指针变量的写法，
例如int arr[10] = { 0 }; int (* p) [10]= &arr;
首先确保p是一个指针变量，用（ * p表示），p指向的是函数，函数有0个或者多个参数，我们就需要把[10]换成函数的参数，里面写上每个参数的类型，前面写上函数的返回值类型。
假设我们要实现一个加法函数，代码如下:
#include <stdio.h>
int ADD(int x, int y)
{
return x + y;
}
int main()
{
int (*pf3)(int, int) = &ADD; //函数的两个参数都是int类型，返回值也是int类型
printf("%d\n", (*pf3)(3, 5));
printf("%d\n", pf3(3, 5));
//函数指针变量pf3存放的是函数的地址，我们之前习惯的是地址解引用得到内容，这样可读性更高
//但是可以通过地址找到函数，所以解引用或者不解引用都可以，之后传递加法函数需要的两个参数
return 0;
}
4.2两个有趣的代码
代码1：
(*(void (*)())0)();
首先我们第一眼看到这个代码可能毫无头绪，需要我们慢慢的思考和理解。
我们可以从里往外看，void ( * )()加上一个指针变量p就变得很眼熟了，
void ( * p)()，这不就是没有参数，并且无返回值的函数指针吗，p的类型是
void (*)()。类型外面有一对大括号，(void ( * )())，类型用大括号括起来，表示的是强制类型转换，加上后面的0，表示把0强制转换成函数指针类型，也就是把0作为地址的形式，然后解引用，表示得到地址为0处的函数，后面的大括号表示函数无参。
总结：这段代码的意思就是，调用地址为0处的函数，并且函数的参数是无参，返回值是void。
代码2：
void (* signal( int, void(*)(int) ) )(int);
首先我们从看起来似乎好理解一些的signal入手，signal后面的大括号，有两个参数，第一个是int类型的参数，第二个是函数指针类型，函数指针指向的函数有一个int类型的参数，并且返回类型是void，两个类型后面都没有形参名，说明这是signal函数的声明，除去signal和后面的大括号，剩下的是void (*)(int)，很明显，这也是函数指针类型，函数指针指向的函数有一个int类型的参数，并且返回类型是void。
上面的代码我们可以这样理解，但是语法不支持这样写，函数名必须要放在 * 的旁边。
总结：
这段代码的意思是signal函数的声明，signal函数有两个参数，一个int类型的参数，一个函数指针类型的参数，函数指针指向的函数参数是int类型，返回类型是void，signal函数的返回类型也是函数指针类型，函数指针指向的函数参数是int类型，返回类型是void。
代码2有两个相同的函数指针，看起来很麻烦，我们可以使用typedef关键字来使代码看起来更简洁。
typedef关键字
typedef关键字是用来给类型重命名的，可以将一些复杂的类型简化成我们好理解，好记的类型。
例如我们想要简化unsigned int类型，我们可以给类型重命名为uint,我们之后想要使用这个类型直接用uint就行。
typedef unsigned int uint;
uint a = 10; //这两条语句等价于unsigned int a = 10;
当我们想给函数指针也重命名，我们可能会这样写
但是编译器会报错，原因还是语法不支持，重命名之后的类型名要紧跟在 * 后面，所以应该这样用。
#include <stdio.h>
typedef int (*ptr_t)(int);//这里的pyr_t是类型名
int main()
{
ptr_t p1;
int (*p2)(int);//重命名后这两行语句是等价的，这里的p2是指针变量名
return 0;
}
这样就成功的把int (*)(int)类型重命名为ptr_t类型。
根据上面的重命名，我们可以简化4.1的代码2，
void (* signal( int, void(*)(int) ) )(int);
简化之后就是ptr_t signal(int,ptr_t)。
5 函数指针数组
根据之前的类推法，我们可以推出：
函数指针数组，是一个数组，数组里面存放的是函数指针，也就是指向函数的指针(函数的地址)
#include <stdio.h>
void hanshu1()
{
}
void hanshu2()
{
}
int main()
{
int (*ptr[2])() = { hanshu1,hanshu2 };
//类似整形指针数组，将hanshu1和hanshu2的地址存放在指针数组ptr[2]里面
//[]的优先级比 * 高，ptr先和[2]结合，表示数组里有两个元素，并且每个元素的类型是int (*)()。
return 0;
}
6 转移表
函数指针的用途：转移表。
转移表的概念：将多个条件分支转化为直接的地址跳转操作
核心思想：利用一个数组来存储函数指针，每个数组元素对应一个可能的分支。当需要进行多重选择时，可以通过计算索引值直接访问数组中的相应元素，从而跳转到对应的处理代码。
假如我们想要简单的实现整数计算器。
最简单粗暴地方法如下：
#include <stdio.h>
void menu()
{
printf("***************************\n");
printf("*******1.add 2.sub *******\n");
printf("*******3.mul 4.div *******\n");
printf("**********0.exit***********\n");
printf("***************************\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()
{
menu();
int input = 0;
int a, b;
int ret = 0;
do {
printf("请输入你的选择:-->");
scanf("%d", &input);
switch (input)
{
case 1:
printf("输入两个数:");
scanf("%d%d", &a, &b);
ret = add(a, b);
printf("%d\n", ret);
break;
case 2:
printf("输入两个数:");
scanf("%d%d", &a, &b);
ret = sub(a, b);
printf("%d\n", ret);
break;
case 3:
printf("输入两个数:");
scanf("%d%d", &a, &b);
ret = mul(a, b);
printf("%d\n", ret);
break;
case 4:
printf("输入两个数:");
scanf("%d%d", &a, &b);
ret = div(a, b);
printf("%d\n", ret);
break;
case 0:
printf("成功退出程序！\n");
break;
default:
printf("输入错误，请重新输入！\n");
break;
}
} while (input);
return 0;
}
在用户输入选择后分别调用对应的函数解决问题，但是这样的代码问题也很明显：太过于冗杂，每一种case情况除了调用的函数不同，其他的部分全部相同，这样会使得代码的效率低下。
这时候我们就会想，这四个函数都是相同的类型，那把这些重复的部分封装在一个代码里面不久能简化代码吗？
#include <stdio.h>
void menu()
{
printf("***************************\n");
printf("*******1.add 2.sub *******\n");
printf("*******3.mul 4.div *******\n");
printf("**********0.exit***********\n");
printf("***************************\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 calu(int (* func)(int,int))//传过来的是函数的地址，用函数指针接收
{
int a, b;
int ret = 0;
printf("输入两个数:");
scanf("%d%d", &a, &b);
ret = func(a, b);//通过接收到的函数的地址加上参数调用函数
printf("%d\n", ret);
}
int main()
{
menu();
int input = 0;
do {
printf("请输入你的选择:-->");
scanf("%d", &input);
switch (input)
{
case 1:
calu(add);
break;
case 2:
calu(sub);
break;
case 3:
calu(mul);
break;
case 4:
calu(div);
break;
case 0:
printf("成功退出程序！\n");
break;
default:
printf("输入错误，请重新输入！\n");
break;
}
} while (input);
return 0;
}
这是一种简化代码的方式，我们还可以通过函数指针数组的方式(转移表)来实现代码的简化。
因为加减乘除都是一样的类型，所以我们可以使用函数指针数组，来存放四个函数的地址，当我们输入选择时，调用数组对应下标的函数来实现功能。
#include <stdio.h>
void menu()
{
printf("***************************\n");
printf("*******1.add 2.sub *******\n");
printf("*******3.mul 4.div *******\n");
printf("***************************\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()
{
menu();
int input = 0;
int a, b;
int ret = 0;
do {
printf("请输入你的选择:-->");
scanf("%d", &input);
int (*arr[])(int, int) = { 0,add,sub,mul,div };//为了使我们输入的数和想要调用的函数下标相同
if (input >= 1 && input <= 4)
{
printf("输入两个数:");
scanf("%d%d", &a, &b);
ret = arr[input](a, b);
//arr[input]能够访问下标为input的数组的元素，也就是访问函数，
//当我们访问函数的时候，需要将参数一起传递过去。
printf("%d\n", ret);
}
else if (input == 0)
{
printf("成功退出程序!\n");
}
else
{
printf("输入错误，请重新输入!\n");
}
} while (input);
return 0;
}
将指针和数组两种结合总结如下：
1.指针数组：是数组，是存放指针（地址）的数组。
例如:int arr[10] = { 0 }; int * p[1]= {arr}; //整形指针数组
p是指针数组，存放整形指针的数组，数组有1个元素。
2.数组指针：是指针，是指向数组的指针，存放的是整个数组的地址。
例如:int arr[10] = { 0 }; int (* p) [10]= &arr; //整形数组指针
p是数组指针，指向arr数组，数组有10个元素，每个元素都是int类型的。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
