【C语言 | 指针】C指针详解(经典,非常详细)

博客主页：https://blog.csdn.net/wkd_007
博客内容：嵌入式开发、Linux、C语言、C++、数据结构、音视频
本文内容：介绍C语言指针
金句分享：

本文未经允许，不得转发！！！

目录

• 一、复杂类型阅读技巧
• 二、了解指针，明确这四个方面
• • ✨2.1 指针变量所在的内存地址
  • ✨2.2 指针变量的值
  • ✨2.3 指针变量的类型
  • ✨2.4 指针变量所指向的类型
• 三、运算符 `&`和 `*`
• 四、指针表达式
• 五、指针算数运算
• 六、常量指针、指针常量
• 七、总结

一、复杂类型阅读技巧

要了解指针，多多少少会出现一些比较复杂的类型，这小节先介绍怎么阅读复杂类型。

下面是一些复杂类型，先自己尝试是否可以清楚变量是什么类型的：

int p;int *p;int *p[3];int (*p)[3];int **p; int p(int); Int (*p)(int);int *(*p(int))[3]; 

这里需要使用一个右左法则来阅读复杂类型：

右左法则：

• 1、从变量名(没变量名的，从最里层的圆括号)开始，先看右边，再看左边；
• 2、如果右边是() 则是函数，如果是 [] 则是数组。
• 3、如果遇到[]，后面还是[]，就先看完右边的[]，再看左边。
  例如：int *pi[4][5];，p先跟[4][5]结合，再跟*结合。

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

二、了解指针，明确这四个方面

如果定义一个基本数据类型变量，我们可以了解到这三个方面的内容：1、变量所在的内存地址； 2、变量的值； 3、变量的类型；

例如：从语句 int i = 1; ，我们可以知道：

• 1、编译器分配一块4个字节(sizeof(int))的内存，地址是&i；
• 2、这块内存里面存放了值为4的内容；
• 3、这个变量是 int 类型的。

如果定义的是指针变量，则我们需要清楚四个方面的内容：

• 1、指针变量所在的内存地址；
• 2、指针变量的值；
• 3、指针变量的类型；
• 4、指针变量所指向的类型。

指针变量和基本数据类型变量的区别就是，编译器会将存放在指针变量里的任何数据都当作地址来处理。

✨2.1 指针变量所在的内存地址

定义了一个任何类型变量，编译器都会为其分配一块内存来存放该变量，起始地址就是 &变量名 ，大小就是该变量的类型的大小。

所以指针变量也是如此，定义指针变量后，编译器会为该变量分配一块内存。内存大小，在32位系统是4个字节，在64位系统是8个字节，可以使用 sizeof(void*) 来打印该系统指针类型的大小。

✨2.2 指针变量的值

指针变量的值是指针变量所在的内存存储的数值，这个值会被编译器当作一个地址，而不是一个一般的数值。

在32 位程序里，所有类型的指针的值都是一个32 位整数，因为32 位程序里内存地址全都是32 位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为 sizeof(指针所指向的类型) 的一片内存区。

以后，我们说一个指针的值是 XX，就相当于说该指针指向了以 XX 为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。指针变量的值==某块内存的首地址

指针所指向的内存区域 和 指针所指向的类型 是两个完全不同的概念。例如语句 int *p;，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。

✨2.3 指针变量的类型

从语法的角度看，你只要把指针声明语句里的指针变量名字去掉，剩下的部分就是这个指针变量的类型。这是指针变量所具有的类型。

让我们看看下面语句中各个指针变量的类型：

(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.4 指针变量所指向的类型

当你通过指针变量来访问指针所指向的内存区时，指针变量所指向的类型 决定了编译器将把那片内存区里的内容当做什么来看待。

从语法上看，你只须把指针声明语句中的指针变量名字和名字左边的指针声明符*去掉，剩下的就是指针变量所指向的类型。例如：

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

在指针的算术运算中，指针变量所指向的类型有很大的作用。

指针变量的类型 和指针变量所指向的类型 是两个概念。当你对C语言越来越熟悉时，你会发现，分清楚指针变量的类型和指针变量所指向的类型 ，是精通指针的关键点之一。

清楚了上面关于指针的四个内容后，我们以后碰到一个指针都要问问自己：①指针是什么类型的？②指针指向的类型是什么？③指针指向的内存是哪里？

看看下面例子：

例：语句int *p = 0x0000FF00;

• 1、分配了一块内存并命名为p，其起始地址是&p，长度为sizeof(int *)；
• 2、这块内存里面存放的值为0x0000FF000，是指针所指向内存的起始地址；
• 3、指针类型是 int*；
• 4、指针所指向的类型是 int，说明0x0000FF000存放着 int 型的内容。

三、运算符 &和 *

指针运算中，&是取地址运算符，用于获取变量所在内存区域的起始地址； *是间接访问运算符，用于访问指针变量所指向的内存区域。

&a 的运算结果是一个指针， 指针的类型是 a 的类型加个*， 指针所指向的类型是 a 的类型， 指针所指向的地址嘛， 那就是 a 的地址。

*p 的运算结果就五花八门了。 总之*p 的结果是 p 所指向的东西，这个东西有这些特点： 它的类型是 p 指向的类型， 它所占用的地址是 p 所指向的地址。

int a=12; int b; int *p; int **ptr;p=&a;//&a 的结果是一个指针，类型是int*，指向的类型是//int，指向的地址是a 的地址。*p=24;//*p 的结果，在这里它的类型是int，它所占用的地址是//p 所指向的地址，显然，*p 就是变量a。ptr=&p;//&p 的结果是个指针，该指针的类型是p 的类型加个*，//在这里是int **。该指针所指向的类型是p 的类型，这//里是int*。该指针所指向的地址就是指针p 自己的地址。*ptr=&b;//*ptr 是个指针，&b 的结果也是个指针，且这两个指针//的类型和所指向的类型是一样的，所以用&b 来给*ptr 赋//值就是毫无问题的了。**ptr=34; //*ptr 的结果是ptr 所指向的东西，在这里是一个指针，//对这个指针再做一次*运算，结果是一个int 类型的变量。

* 后面加一个合法的内存地址，就可以操作该段内存。所以我们甚至可以将数值存储到指定的内存地址，用下面这种方式：

*((int*)0x0000ff00) = 100;// 0x0000ff00 必须是合法地址，否则段错误。

四、指针表达式

一个表达式的结果如果是一个指针， 那么这个表达式就叫指针表式。

左值 和 右值

• 左值通常是可以操作的一块内存区域，一般可以通过&取到该内存起始地址，这块内存的值可以被修改。例如：变量、*(指针)、数组元素等；
• 右值一般是没有明确的内存位置，无法使用&获取地址，值不可被修改。例如：立即数、常量、字面值、&(变量)。

赋值号 = 要求两边的类型是一致的，不然的话，需要显式类型转换 或 隐式类型转换。

下面是一些指针表达式的例子：

int a,b;int array[10];int *pa;pa=&a; //&a 是一个指针表达式。int **ptr=&pa; //&pa 也是一个指针表达式。*ptr=&b; //*ptr 和&b 都是指针表达式。pa=array;pa++; //这也是指针表达式。char *arr[20];char **parr=arr; //如果把arr 看作指针的话，arr 也是指针表达式char *str;str=*parr; //*parr 是指针表达式str=*(parr+1); //*(parr+1)是指针表达式str=*(parr+2); //*(parr+2)是指针表达式

由于指针表达式的结果是一个指针，所以指针表达式也具有指针所具有的四个要素：指针所在的内存地址、指针的值、指针的类型、指针所指向的类型。

当一个指针表达式的结果指针已经明确地具有了指针所在的内存地址的话，这个指针表达式就是一个左值，否则就不是一个左值。在上面代码中，&a 不是一个左值，因为它还没有占据明确的内存。*ptr 是一个左值，因为*ptr 这个指针已经占据了内存，其实*ptr 就是指针pa，既然 pa 已经在内存中有了自己的位置，那么*ptr 当然也有了自己的位置。

五、指针算数运算

指针可以加上或减去一个整数。
指针加上一个整数，得到的地址是，指针的值 + sizeof(指针所指向的类型)；
指针减去一个整数，得到的地址是，指针的值 – sizeof(指针所指向的类型)；

看例子：

// point_operation.c// 2023-11-14 14:59:02#include char fun(char* pc, int* pi){}int main(void){char c;short s;int i;char arr[5];int iar[4][5];// 指针所指向的类型char*pc = &c;// charshort *ps = &s;// shorint *pi = &i;// intchar (*p_arr)[5] = &arr;// char [5]int(*p_iar)[4][5] = &iar;// int [4][5]char (*p_fun)(char*, int*) = fun;// char (char*, int*)printf("pc=%p,(pc+1)=%p,0x%lx\n", pc, pc+1, (unsigned long)pc+sizeof(char));printf("ps=%p,(ps+2)=%p,0x%lx\n", ps, ps+2, (unsigned long)ps+2*sizeof(short));printf("pi=%p,(pi-3)=%p,0x%lx\n", pi, pi-3, (unsigned long)pi-3*sizeof(int));printf("p_arr =%p,(p_arr+1) =%p,0x%lx\n", p_arr, p_arr+1, (unsigned long)p_arr+sizeof(char [5]));printf("p_iar =%p,(p_iar+1) =%p,0x%lx\n", p_iar, p_iar+1, (unsigned long)p_iar+sizeof(int [4][5]));printf("p_fun =%p,(p_fun+1) =%p,0x%lx\n", p_fun, p_fun+1, (unsigned long)p_fun+sizeof(char (char*, int*)));return 0;}

保存后，编译，运行结果如下：

从运行结果来看，指针加减一个整数之后的值，等于指针的值 + sizeof(指针所指向的类型)。
所以，以后遇到指针运算时，最重要的一点是，找出该指针所指向的类型是什么。

在例子中，还有一个有趣的地方，sizeof关键字居然可以对奇怪的类型如：char [5]、int [4][5]、char (char*, int*)，计算出其占用内存大小。

六、常量指针、指针常量

在C语言中，常量指针和指针常量是两个不同的概念。

常量指针：指针本身是不可变的，但指针所指向的内容可以被修改。声明时使用const关键字放在星号前面。例如：

int x = 5;int *const ptr = &x; // 这里ptr是一个常量指针，它指向x，但ptr本身的值不能被改变*ptr = 10; // 合法，可以通过ptr修改x的值ptr++; // 非法，因为ptr本身是不可变的

指针常量：指向常量的指针，指针所指向的内容是不可变的。声明时使用const关键字放在指针名字前面。例如：

const int y = 3;const int *ptr; // 这里ptr是一个指针常量，它指向的内容是不可变的ptr = &y; // 合法，ptr可以指向y*ptr = 6; // 非法，因为ptr指向的内容是不可变的

七、总结

本文介绍了指针的四个要素：指针所在的内存地址、指针的值、指针的类型、指针所指向的类型。指针常用运算符，指针表达式，指针运算等内容。

如果文章有帮助的话，点赞、收藏⭐，支持一波，谢谢

参考资料：
《让你不再害怕指针.pdf》
《C语言深度剖析》