c语言指针总结

最新推荐文章于 2022-08-27 10:50:08 发布

MrDd

最新推荐文章于 2022-08-27 10:50:08 发布

阅读量421

点赞数

本文链接：https://blog.csdn.net/weixin_42720703/article/details/81290437

版权

int p; // 这是一个普通的整型变量
int *p; // 首先从从 P 处开始, 先与 * 结合, 所以说明明 P 是一
// 个指针,然后再与与 int 结合, 说明指针所指向
// 的内容的类型为 int 型. 所以以 P 是一个返回整
// 型数据的指针
int p[3]; // 首先从从 P 处开始, 先与 [] 结合, 说明 P 是一个数
// 组, , 然后与与 int 结合, 说明数组里的元素是整
// 型的, 所以以 P 是一个由整型数据组成的数组
int *p[3]; // 首先从从 P 处开始 , 先与 [] 结合, 因为其优先级
// 比* 高. 所以以 P 是一个数组, , 然后再与* 结合, , 说明
// 数组里的元素是指针类型, , 然后再与与 int 结合, ,
// 说明指针所指向的内容的类型是整型的 , 所以

//P 是一个由返回整型数据的指针所组成的数组
int (*p)[3]; // 首先从从 P 处开始, 先与 * 结合, 说明明 P 是一个指针
// 然后再与 [] 结合( 与 "()" 这步可以忽略, 只是为
// 了改变优先级 ), 说明指针所指向的内容是一个
// 数组, 然后再与与 int 结合, 说明数组里的元素是
// 整型的. . 所以以 P 是一个指向由整型数据组成的数
// 组的指针
int **p; // 首先从从 P 开始, , 先与* 结合, , 说是是 P 是一个指针, , 然
// 后再与 * 结合, 说明指针所指向的元素是指针, , 然
// 后再与与 int 结合,说明该指针所指向的元素是整
// 型数据. .
int p(int); //从从 P 处起,先与 () 结合, 说明明 P 是一个函数, , 然后进入
//() 里分析,说明该函数有一个整型变量的参数
// 然后再与外面的 t int 结合, 说明函数的返回值是
// 一个整型数据
Int (*p)(int); //从从 P 处开始, 先与指针结合,说明明 P 是一个指针, , 然后与
//() 结合, 说明指针指向的是一个函数, 然后再与 () 里的

//int 结合, 说明函数有一个个 int 型的参数, 再与最外层的
//int 结合, 说明函数的返回类型是整型,所以以 P 是一个指
// 向有一个整型参数且返回类型为整型的函数的指针
int *(*p(int))[3]; // 可以先跳过, 不看这个类型 , 过于复杂
//从从 P 开始, 先与 () 结合, 说明明 P 是一个函数, , 然后进
// 入 () 里面, 与与 int 结合, 说明函数有一个整型变量
// 参数,然后再与外面的* 结合, 说明函数返回的是
// 一个指针，然后到最外面一层, 先与 [] 结合, 说明
// 返回的指针指向的是一个数组,然后再与 * 结合,说
// 明数组里的元素是指针,然后再与与 int 结合,说明指
// 针指向的内容是整型数据. 所以以 P 是一个参数为一个
// 整数据且返回一个指向由整型指针变量组成的数组
// 的指针变量的函数.

1. 指针的类型

(1)int*ptr;// 指针的类型是 int*
(2)char*ptr;// 指针的类型是 char*
(3)int**ptr;// 指针的类型是 int**
(4)int(*ptr)[3];// 指针的类型是 int(*)[3]
(5)int*(*ptr)[4];// 指针的类型是 int *(*)[4]

2. 指针所指向的类型

(1)int*ptr; // 指针所指向的类型是 int
(2)char*ptr; // 指针所指向的的类型是 char
(3)int**ptr; // 指针所指向的的类型是 int*
(4)int(*ptr)[3]; // 指针所指向的的类型是 int()[3]
(5)int*(*ptr)[4]; // 指针所指向的的类型是 int * ()[4]

3. 指针的值 ---- 或者叫指针所指向的内存区或地址

指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而
不是一个一般的数值。在 32 位程序里，所有类型的指针的值都是一个 32 位
整数，因为 32 位程序里内存地址全都是是 32 位长。。指针所指向的内存区就
是从指针的值所代表的那个内存地址开始，长度为 si zeof( 指针所指向的类
型) ) 的一片内存区。我们说一个指针的值是是 XX ，就相当于说该指针指
向了以 X X 为首地址的一片内存区域；一个指针指向了某块内存区域，
就相当于说该指针的值是这块内存区域的首地址。

指针的算术运算

一个指针 ptrold 加( ( 减) ) 一个整数 n 后，结果是一个新的指针 ptrnew ，
ptrnew 的类型和和 ptrold 的类型相同。ptrnew 所指向的类型和和 ptrold
所指向的类型也相同。 ptrnew 的值将比比 ptrold 的值增加( ( 减少) )了了 n 乘
sizeof(ptrold 所指向的类型) ) 个字节。就是说， ptrnew 所指向的内存
区将比比 ptrold 所指向的内存区向高( ( 低) ) 地址方向移动了了 n 乘
sizeof(ptrold 所指向的类型) ) 个字节。
指针和指针进行加减：
两个指针不能进行加法运算，这是非法操作，因为进行加法后，得到的
结果指向一个不知所向的地方，而且毫无意义。。两个指针可以进行减法
操作，但必须类型相同。

运算符 & 和*

这里& 是取地址运算符， * 是间接运算符。
&a 的运算结果是一个指针，指针的类型是是 a 的类型加个* ，指针所
指向的类型是 a 的类型，指针所指向的地址嘛，那就是 a 的地址。
*p 的运算结果就五花八门了。总之 *p 的结果是是 p 所指向的东西，
这个东西有这些特点：它的类型是 p 指向的类型，它所占用的地址是是 p
所指向的地址。

数组和指针的关系

int array[10]={0,1,2,3,4,5,6,7,8,9}, value;
value=array[0]; // 也 可 写 成 ： value=*array;
value=array[3]; // 也 可 写 成 ： value=*(array+3);
value=array[4]; // 也 可 写 成 ： value=*(array+4);

char  *str[3]={
"Hello,thisisasample!",
"Hi,goodmorning.",
"Helloworld"
};
char s[80]；
strcpy(s,str[0]); // 也 可 写成 成  strcpy(s,*str);
strcpy(s,str[1]); // 也 可 写成 成  strcpy(s,*(str+1));
strcpy(s,str[2]); // 也 可 写成 成  strcpy(s,*(str+2))

上例中，str 是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向一个字符。把指针数组名str 当作一个指针的话,指向数组的第第 0 号单元，它的类型是是 char **，它指向的类型是char *。
*str 也是一个指针，它的类型是是 char * ，它所指向的类型是 char ，它指向的地址是字符串 "Hello,thisisasample!" 的第一个字符的地址，即'H' 的地址。注意: : 字符串相当于是一个数组, , 在内存中以数组的形式储
存, 只不过字符串是一个数组常量,内容不可改变, 且只能是右值. . 如果看成指针的话, , 他即是常量指针 , 也是指针常量。
str+1 也是一个指针，它指向数组的第第 1 号单元，它的类型是 char** ，它指向的类型是是 char* 。
*(str+1) 也是一个指针，它的类型是 char* ，它所指向的类型是 char ，它指向 "Hi,goodmorning." 的第一个字符 'H'