目录
- 1. 字符指针变量
- 2. 数组指针变量
- 2.1 什么是数组指针变量
- 2.2 数组指针变量的初始化
- 3. 二维数组传参的本质
- 4. 函数指针变量
- 4.1 函数指针变量的创建
- 4.2 函数指针变量的使用
- 4.3 代码分析
- 4.3.1 typedef 关键字
- 5. 函数指针数组
- 6. 转移表
正文开始。
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");
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;
}
运行结果：
从这里就可以看出，几个指针指向同一个字符串的时候，他们会指向同一块内存；但用相同的字符串去初始化不同的数组时，就会开辟处不同的内存块。
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 重命名为 i
typedef unsigned int uint;
//将 unsigned int 重命名为 uint
typedef int(*parr)[5];
//将 int (*)[5] 重命名为 parr
typedef void(*pfun)(int);
//将 void(*)(int) 重命名为 pfun
若要简化代码2，我们可以这样写：
typedef void(*pfun)(int);
//将 void(*)(int) 重命名为pfun
pfun 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;
}
完。
![[Java EE] 多线程(三):线程安全问题(上)](https://img-blog.csdnimg.cn/direct/c86f8dc52fec4c0d9f8f16d9cce56777.png)
