通用型指针，函数指针，数组指针

怼烎@ 2022-11-26 09:46 209阅读 0赞

一、通用类型指针？  
1、强制转换类型。  
int a = 100;  
int \*pa = &a;

char b = 'x';  
char \*pb = &b;

在这里，我们能不能将&b赋值给pa，把&a赋值给pb？  
int \*pa = &b;  
char \*pb = &a; -> 编译警告： warning: initialization from incompatible pointer type  
//两边的类型不一致

int \*pa = (int \*)&b;  
char \*pb = (char \*)&a; -> 编译通过。

强制转换类型：int \*pa = (int \*)&b; &b默认是char\*类型的指针，(int\*)就是将这个&b地址强制转换为int\*类型的指针。  
(&b这个地址是指向第一层楼的，但是现在是指向前4层楼)  
本来&b指向一个char类型的数据，但是现在指向int类型的数据。

2、什么是通用类型的指针？  
通用类型指针变量其实就是可以存放任何类型的指针变量，也就是说什么类型的指针都可以赋值给通用类型的指针。

int\*pa -> 只能赋值一些int\*类型的指针，否则就会报错。  
char\*pb -> 只能赋值一些char\*类型的指针，否则就会报错。

通用类型指针类型： void\*  
通用类型指针变量： void\*px -> 任何类型的指针(无论是char\*,int\*,float\*,double\*),都可以存放在void \*px这个变量。  
（只是用来装地址的变量，至于这个地址指向什么数据，它就不知道了）

3、通用类型指针有什么作用？ -> 解析强制转换类型的意义。  
1）任意特定类型指针都可以赋值给通用类型指针。

int a; ->变量a的地址是int\*类型  
char b; ->变量b的地址是char\*类型  
double c;->变量c的地址是double\*类型

void \*p = &a;  
void \*p = &b;  
void \*p = &c;

以上几句话含义是什么意思？  
仅仅是把a变量的地址,b变量的地址，c变量的地址的那个地址值赋值了p，一旦赋值了给p之后，这个地址指向的内容就变成了未知。

2）通用类型指针变量赋值给一写特定类型的指针变量？

int a = 100; //在内存中连续申请4个字节，然后使用变量a间接访问这片内存空间。  
void \*p = &a; //将a对应的这片空间的地址赋值給通用类型的指针p，这时候p确实可以保存a的地址，但是p指向的内容是未知的。  
char \*pa = p; //将a对应的这片空间的地址赋值給指针变量pa，这时候pa确保是保存着a的地址，而且非常明确地知道pa是指向一个字符类型的数据。

3）综上所述：  
int a;  
int \*pa = &a; //pa是存放着a的地址，pa指向int类型的数据。  
void \*p = pa; //p是存放着a的地址，p指向未知的区域。  
char \*pb = p; //pb是存放着a的地址，pb指向char类型的数据。

等价于

int a;  
char \*pb = (char \*)&a; ->强制类型转换就是使用void \*去解析的。

4）易错点。  
void a; -> 没有void型变量，只有void\*变量。  
void \*p = &a;

int a = 100;  
void \*p = &a;  
int b = \*p; -> 编译出错：不能解引用void\*指针。

结论： 如果你一定要解引用通用类型的指针，想得到这个指针指向的东西，那么就一定要先将通用类型指针强制转换为某种特定的指针。

正确：  
int a = 100;  
void \*p = &a;  
int b = \*(int\*)p;

二、指针运算。  
1、指针的加减法。  
int a = 100;  
int \*pa = &a; //pa就是存放着a的地址

pa+1 -> 将a的地址往上偏移1个单位

pa -> a的地址  
\+ -> 代表地址往上偏移 - -> 代表地址往下偏移  
1 -> 代表1个单位

1个单位究竟等于多少字节？ -> 取决于指针指向的内容的数据类型。  
例如： 指针指向一个int类型的空间，那么往上偏移一个单位，就等于偏移了4个字节。

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a = 100;  
int \*pa = &a;  
  
printf("pa = %p\\n",pa); //1c  
printf("pa+1 = %p\\n",pa+1); //20  
printf("pa-1 = %p\\n",pa-1); //18  
return 0;  
\}

2、两个地址能不能相加？ -> 无论类型是否一致，都不可以相加。

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a;  
int b;  
char c;

int \*pa = &a;  
int \*pb = &b;  
char \*pc = &c;

//printf("pa+pb = %p\\n",pa+pb); 不可以，编译报错  
//printf("pa+pc = %p\\n",pa+pc); 不可以，编译报错  
\}

3、 两个地址能不能相减？  
如果类型一致，则可以相减，结果为两个地址之间相差的单位数。  
如果类型不一致，则不可以相减。

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a;  
int b;  
char c;

int \*pa = &a;  
int \*pb = &b;  
char \*pc = &c;  
  
/\*  
printf("pa = %p\\n",pa);  
printf("pb = %p\\n",pb);  
printf("pa-pb=%ld\\n",pa-pb); 可以，得到两个地址相差的单位  
\*/  
  
printf("pa-pc = %ld\\n",pa-pc); 不可以，编译报错  
\}

练习1： 验证数组的名字是等价于数组首元素的地址，而不是数组的地址。

什么是数组首元素的地址？  
这个地址是指向数组的首元素而已。

什么数组的地址？  
这个地址是指向整个数组的。

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int A\[3\];  
printf("A = %p\\n",A);  
printf("&A\[0\] = %p\\n",&A\[0\]);  
printf("&A = %p\\n",&A);  
  
printf("A+1 = %p\\n",A+1);  
printf("&A\[0\]+1 = %p\\n",&A\[0\]+1);  
printf("&A+1 = %p\\n",&A+1);  
\}

结果：  
A = 0x7ffcb0b19b90  
&A\[0\] = 0x7ffcb0b19b90  
&A = 0x7ffcb0b19b90  
A+1 = 0x7ffcb0b19b94  
&A\[0\]+1 = 0x7ffcb0b19b94  
&A+1 = 0x7ffcb0b19b9c

三、数组运算。  
1、由于数组名是数组首元素的地址  
int A\[3\]  
A 等价于 &A\[0\] 地址类型：int\* -> 这个地址是指向一个int类型(4个字节)的数据(首元素)

2、 数组运算。  
A -> 首元素的地址 -> &A\[0\]  
A+1 -> 首元素的地址往上偏移一个单位(4个字节) -> 第二个元素的地址 -> &A\[1\]  
A+2 -> 首元素的地址往上偏移二个单位(8个字节) -> 第三个元素的地址 -> &A\[2\]

\*A -> \*(&A\[0\]) -> A\[0\] -> 解引用首元素的地址，得到首元素的值。  
\*(A+1) -> \*(&A\[1\]) -> A\[1\] -> 解应用第2个元素的地址，得到第2个元素的值。  
\*(A+2) -> \*(&A\[2\]) -> A\[2\] -> 解应用第3个元素的地址，得到第3个元素的值。

\*(A+0) 等价于 A\[0\]  
\*(A+1) 等价于 A\[1\]  
\*(A+2) 等价于 A\[2\]

结论：数组的下标其实就是数组首元素的地址往上偏移的单位数。  
\*(A+N) 等价于 A\[N\]

3、执行A++,会有什么结果出现？  
编译出错。A++ 等价于 A=A+1。  
A是数组名来的，所以等价于首元素的地址(常量) -> A就是一个常量,所以不能被赋值。

结论： 数组的本身是变量 -> 数组里面值可以随便换 A\[0\]=10 A\[0\]=100  
数组名是一个常量 -> 不能对数组名进行赋值。 A=A+1

4、加法交换律。  
A\[N\] 等价于 \*(A+N) 等价于 \*(N+A) 等价于 N\[A\]

\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int A\[3\] = \{100,200,300\};  
printf("A\[0\] = %d\\n",A\[0\]); //100  
printf("\*(A+0) = %d\\n",\*(A+0)); //100  
  
printf("\*(0+A) = %d\\n",\*(0+A)); //100  
printf("0\[A\] = %d\\n",0\[A\]); //100  
  
return 0;  
\}

结论： 已知一个数组，调用某一个元素时：  
"数组名\[下标\]" 等价于 "下标\[数组名\]"

定义数组，必须遵循：  
数据类型 数组名\[元素的个数\]

四、复杂指针定义。  
1、什么是复杂指针？  
无论是简单指针还是复杂指针，都是用于存放内存空间上的地址值。例如：0x100  
简单指针： 该地址指向一些基本数据类型 char\*/int\*/float\*  
复杂指针： 该地址指向一些非基本数据类型 指针/数组/函数/结构体 -> 二级指针/数组指针/函数指针/结构体指针

2、二级指针？  
1）什么是二级指针？  
二级指针就是指向指针的指针。

2）如何定义二级指针？

第一步：先写一个\* \*  
第二步：在\*后面写一个变量名 \*px  
第三步：确认这个指针指向的内容是什么 int \*p  
第四步：将第三步的结果的变量名去掉 int \*  
第五步：将第四步的结果写在第二步的前面 int\*\*px

分析结果：int\*\*px

数据类型：int\*\*  
变量名： px

结论：  
int a = 100;  
int \*p = &a; //p就是一级指针  
int \*\*px = &p; //px就是二级指针

3）解引用。  
\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
int a = 100;  
int \*p = &a;  
int \*\*px = &p;  
  
printf("a = %d\\n",a);  
printf("p = %p\\n",p);  
printf("px = %p\\n",px);  
  
printf("\*px = %p\\n",\*px); //\*px = \*(&p) = p  
printf("\*\*px = %d\\n",\*\*px); //\*p = \*(&a) = a  
  
return 0;  
\}

练习2： 完成6、7、8题。

3、数组指针  
1）什么是数组指针？  
是一个指针变量，然后这个变量中存放着整个数组的地址。

2）如何定义数组指针？  
定义整型指针如下：  
int a = 10;  
int \*pa = &a;

分析：int \*pa; -> 指向"int a"这种变量的指针。  
数据类型： int\* -> 这种数据类型的变量是专门用于存储整型变量的地址  
变量名：pa

定义数组指针？  
int A\[3\];  
int (\*px)\[3\] = &A; ->把整个数组地址赋值給px

第一步：先写一个\* \*  
第二步：在\*后面写一个变量名，使用()将结果括起来 (\*px)  
第三步：确定你指向的内容是什么 int A\[3\]  
第四步：将第3步的结果的变量名去掉 int \[3\]  
第五步：将第2步的结果放在第4步结果的类型与元素个数中间 int (\*px)\[3\]

分析结果： int (\*px)\[3\] -> 指向"int A\[3\]"这种数组的指针  
数据类型： int (\*)\[3\] -> 这种数据类型的变量是专门用于储存一个具有3个int类型数组的地址。  
变量名： px

3）能不能这样写？  
int A\[3\]  
int \*p = A; -> 正确的，把数组A的首元素的地址赋值給p。  
int (\*px)\[3\] = &A; -> 正确的，把数组A的地址赋值給px。

int \*p = &A; -> 错误的，左边的类型：int \* 右边的类型： int(\*)\[3\]  
int (\*px)\[3\] = A; -> 错误的，左边的类型：int(\*)\[3\] 右边的类型： int \*

4）解引用。  
int a = 100;  
int \*pa = &a; -> pa就是指向int类型数据  
请问\*pa得到什么？

分析： \*pa -> \*(&a) -> a -> 100  
结论： 解引用一个整型指针，那么就得到这个指针指向整型变量的值。

int A\[3\] = \{1,2,3\};  
int (\*pA)\[3\] = &A; -> pA就是指向整个数组的。  
请问\*pA得到什么？

分析： \*pA -> \*(&A) -> A -> 数组名 -> 数组首元素的地址 -> &A\[0\]  
结论： 解引用一个数组指针，那么就可以得到这个指针指向的那个数组的首元素的地址。

5）已知  
int A\[3\] = \{100,200,300\};  
int (\*p)\[3\] = &A;  
以下的几个式子代表什么含义？  
p\[0\] 等价于 \*p 数组首元素的地址  
p\[1\] -> 随机值/段错误 -> 越界访问了一些未申请的内存空间  
(\*p)\[0\] -> 数组首元素的值。  
(\*p)\[1\] -> 数组第2个元素的值

分析：  
p\[0\] = \*(p+0) = \*(&A+0) = \*(&A) = A = &A\[0\] -> 数组首元素的地址  
p\[1\] = \*(p+1) = \*(&A+1) &A+1已经越界了，再解应用就会得到未知值。  
(\*p)\[0\] = (\*&A)\[0\] = A\[0\] -> 100 -> 数组首元素的值  
(\*p)\[1\] = (\*&A)\[1\] = A\[1\] -> 200 -> 数组第2个元素的值

练习2： 如果有以下的说明：  
int B\[10\];  
int (\*p)\[10\] = &B;  
int \*px = B;  
则以下能正确引用数组的元素的是？  
A. \*p+1 B. \*(p\[1\]) C. (px+3)\[2\] D. (\*px)\[3\] E. (\*p)\[0\] F. \*(px+1)

4、 函数指针。  
1）什么是函数指针？  
在程序运行时，函数也是会在内存中申请空间的，函数也是有地址，这个装函数的地址变量叫做函数指针变量。

2）如何定义函数指针？  
整型指针：  
int a; //定义好目标  
int \*pa = &a;  
\*pa求出a代表的空间里面的值。

函数指针：  
void fun(int a,char b); //定义好你的目标  
void (\*p)(int,char) = &fun; -> 在C语言中，函数的名字就是函数的地址 -> fun 等价于 &fun  
等价于：  
void (\*p)(int,char) = fun;

请问\*p得到什么？  
\*p = \*(&fun) = fun = &fun;

fun 等价于 &fun 等价于 \*fun

根据5个步骤来写函数指针：  
第一步：先写一个\* \*  
第二步：在\*后面写一个变量名，然后使用()括他们 (\*p)  
第三步：确定你指向的目标是什么 void fun(int a,char b)  
第四步：将第3步的结果的函数名与形式参数的名字去掉 void (int,char)  
第五步：将第2步的结果写在第4步结果的返回值类型与形式参数列表中间 void (\*p)(int,char)

分析结果： void (\*p)(int,char)

数据类型： void (\*)(int,char) ->这种类型的变量专门用于存放一个没有返回值并且有1个int类型，1个char类型形式参数的函数的地址。  
变量名： p

例题： 求出两个数组的最大值，使用函数指针来完成。

fun 等价于 &fun  
p 等价于 \*p

\#include <stdio.h>

//1. 定义好目标  
int get\_max(int a,int b);

int get\_max(int a,int b)  
\{  
return (a > b ? a : b);  
\}

int main(int argc,char \*argv\[\])  
\{  
//2. 定义函数指针  
int(\*p)(int,int) = get\_max; 等价于 int(\*p)(int,int) = &get\_max;  
  
//3. 直接调用函数指针，就等于调用函数。  
int ret;  
ret = (\*p)(10,20); 等价于 ret = p(10,20);  
printf("ret = %d\\n",ret);  
return 0;  
\}

例如： 想使用pthread\_cleanup\_push，参数怎么填？

void pthread\_cleanup\_push(void (\*routine)(void \*),void \*arg);

1. 第一个参数是一个函数指针，所以第一个参数必须传递一个函数給它。  
2. 分析函数指针：void (\*routine)(void \*)

已知： void (\*routine)(void \*)  
求函数长什么？

假设函数为： xxx fun(yyy a)  
那么函数指针为： xxx(\*routine)(yyy)  
推断： xxx -> void yyy -> void \*  
函数原型： void fun(void \* a)

3. 也就是说，我们调用这个pthread\_cleanup\_push，第一个参数的函数必须是长这个样子的： void fun(void \* a)  
4. 大概模型：  
void fun(void \*a)  
\{

pthread\_cleanup\_push(fun,....)