---

正文开始。

1. 字符指针变量

我们可以通过指针来指向一个字符变量
例如：

int main()
{char ch = 'a';char* pch = &ch;return 0;
}

还可以这样：

int main()
{const char* pstr = "hello world!";return 0;
}

上述第三行代码，很容易让人理解为是把字符串hello world!放到了字符指针pstr里了。但其实这里本质是把字符串hello world!的首字符的地址放到了pstr里。

值得注意的是：当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。这也不难理解，某一字符串是独一无二的，没必要为同一个东西再开辟空间。

例如：

#include <stdio.h>
int main()
{char str1[] = "hellw world!";char str2[] = "hellw world!";const char *str3 = "hellw world!";const char *str4 = "hellw world!";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");return 0;
}

运行结果：

从这里就可以看出，几个指针指向同一个字符串的时候，他们会指向同一块内存；但用相同的字符串去初始化不同的数组时，就会开辟处不同的内存块。

2. 数组指针变量

2.1 什么是数组指针变量

在上一篇文章中，我们学习了指针数组，它是存放指针的数组。
类比指针数组，不难理解，数组指针变量就是指向数组的指针变量

下面我们来看两种变量：

//指针数组 - 存放指针的数组
int* p1[10];//数组指针变量 - 指向数组的指针变量
int (*p2)[10];

理解：

• *的优先级低于[]
• int* p1[10]中p1先与[10]结合，代表数组类型，int *指明数组中元素的类型为整型指针
• int (*p2)[10]中p2先与 * 结合，代表指针类型，int [10]代表所指向对象的类型为存放了十个整型元素的数组

2.2 数组指针变量的初始化

数组指针变量是用来存放数组地址的，我们可以通过取地址操作符&来获取数组地址。

int main()
{int arr[10] = { 0 };//数组指针变量的初始化int (*p)[10] = &arr;return 0;
}

3. 二维数组传参的本质

在我们将一个二维数组传递给一个函数时，我们是这样写的：

#include <stdio.h>void Print(int arr[2][3], int row, int col)
{int i = 0;int j = 0;for(i = 0; i< row; i++){for(j = 0; j < col; j++){printf("%d ",arr[i][j]);}printf("\n");}
}int main()
{int arr[2][3] = {{1,2,3}, {2,3,4}};Print(arr,2,3);return 0;
}

我们再重新理解下二维数组，二维数组定义时，通常像这样int arr[2][3]，这里我们可以看作是这样的int (arr[2])[3]，即一维数组里面存放的元素是一维数组，这样就把一个二维数组拆分成了两个一维数组来看。例如第一行的一维数组的类型就是int [3]，所以第一行的地址的类型就是数组指针类型int(*)[5]。通过这一点，我们不难理解，二维数组传参本质上也是传递了参数，传递的是第一行这个一维数组的地址。

那么，我们二维数组传参，也可以写成这样：

#include <stdio.h>void Print(int (*p)[3], int row, int col)
{int i = 0;int j = 0;for(i = 0; i < row; i++){for(j = 0; j < col; j++){printf("%d ", *(*(p + i) + j));//p + i == &arr[i]//*(p + i) == arr[i] 相当于第i行一维数组的数组名//*(p + i) + j == &arr[i][j]//*(*(p + i) + j) == arr[i][j]}printf("\n");}
}
int main()
{int arr[2][3] = {{1,2,3}, {2,3,4}};Print(arr,2,3);return 0;
}

上述代码运行结果：

4. 函数指针变量

函数指针变量，顾名思义，它就是存放函数地址的指针变量。

在学习函数指针变量前，我们要了解到，函数名就是函数的地址。

例如：

#include <stdio.h>
//函数地址 -- &Add
//函数地址 -- Add
int Add(int x, int y)
{return x + y;
}
int main()
{printf("&Add = %p\n", &Add);printf("Add  = %p\n", Add);return 0;
}

上述代码运行结果：

4.1 函数指针变量的创建

当我们想把函数的地址存放起来，这是就需要用到函数指针变量了，函数指针变量的写法与数组指针非常类似。例如：

#include <stdio.h>int Add(int x, int y)
{return x + y;
}
int main()
{int (*p1)(int, int) = Add;
//或int (*p2)(int x, int y) = Add;
//Add也可写为&Add，它们都代表函数的地址//int    (*p1)     (int, int)
// |       |       ——————————
// |       |            |
// |       |            |
// |       |       p1指向函数的参数类型和个数的声明
// |       函数指针变量名
// p1指向函数的返回类型
//
// p1的类型 -- int (*) (int x, int y)return 0;
}

4.2 函数指针变量的使用

我们可以通过函数指针调用指针指向的函数

#include <stdio.h>int Add(int x, int y)
{return x + y;
}
int main()
{//函数指针变量定义int (*p1)(int, int) = Add;//函数指针变量使用printf("%d\n",(*p1)(3,4));printf("%d\n", p1(5,1));return 0;
}

上述代码运行结果：

4.3 代码分析

我们来看下面两个代码

代码1：

(*(void (*)())0))();
//void (*)() -- 函数指针类型，所指向对象无形参，无返回值//(void (*)())0 -- 将0强制转换类型为void (*)()类型，即将0地址处存放函数的地址//*(void (*)())0) -- 解引用函数指针//(*(void (*)())0))() -- 调用函数指针变量指向的函数

代码2：

void (*signal(int, void(*)(int)))(int);
//void(*)(int) -- 函数指针变量，指向的函数无返回值，参数类型为int//signal(int, void(*)(int)) -- 函数名为signal的函数，第一个参数类型为int，第二个参数类型为void(*)(int)//void (*signal(int, void(*)(int)))(int) -- 函数signal(int, void(*)(int))的声明，它的返回值类型为void (*)(int)

4.3.1 typedef 关键字

上面我们写的代码二的作用就是声明一个函数，可以看出来，这个函数声明非常的复杂，我们可以通过typedef关键字来重命名类型，简化类型。

例如：

typedef int i;
//将 int 重命名为 itypedef unsigned int uint;
//将 unsigned int 重命名为 uinttypedef int(*parr)[5];
//将 int (*)[5] 重命名为 parrtypedef void(*pfun)(int);
//将 void(*)(int) 重命名为 pfun

若要简化代码2，我们可以这样写：

typedef void(*pfun)(int);
//将 void(*)(int) 重命名为pfunpfun signal(int, pfun);

5. 函数指针数组

函数指针数组，就是存放函数指针变量的数组。

定义如下：

int (*parr[4])();
//  parr -- 数组名
//  [4] -- 数组元素个数
//  int (*)() -- 数组中元素的类型

6. 转移表

函数指针数组可以用来书写转移表——运用函数指针数组以数组方式去调用里面的函数，从而在某些情况下替代冗长的代码。我们通过计算器的例子来学习一下吧。

计算器的一般实现：

#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(" 0:exit                  \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");break;default:printf("选择错误\n");break;}} while (input);//计算器的一般实现return 0;
}

使用转移表实现计算器：

#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 (*arr[5])(int, int) = {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 >= 1 && input <= 4){printf("输入操作数：");scanf("%d%d", &x, &y);ret = *(arr[input])(x,y);//调用函数指针数组中的元素printf("ret=%d\n", ret);}else if(input == 0){printf("程序退出\n");}else{printf("输入错误\n");}} while(input);return 0;
}

完。

---