C语言指针详解(一）超详细~

1.内存和地址

1.1 内存

在讲内存和地址之前，我们想有个生活中的案例：

假设有一栋宿舍楼，把你放在楼里，楼上有100个房间，但是房间没有编号，你的一个朋友来找你玩，如果想找到你，就得挨个房子去找，这样效率很低，但是我们如果根据楼层和楼层的房间的情况，给每个房间编上号，如：

一楼：101，102，103...
二楼：201，202，203....
...

有了房间号，如果你的朋友得到房间号，就可以快速的找房间，找到你。

生活中，每个房间有了房间号，就能提高效率，能快速的找到房间。

如果把上面的例子对照到计算中，又是怎么样呢？

我们知道上CPU(中央处理器)在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何高效的管理呢？

其实也是把内存划分为一个个的内存单元，每个内存单元的大小取1个字节。

计算机中常见的单位(补充)：

一个比特位可以存储一个2进制的位1或者0

1 bit - 比特位
2 byte - 字节
3 KB
4 MB
5 GB
6 TB
7 PB

1byte = 8bit
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB

其中，每个内存单元，相当于一个学生宿舍，一个人字节空间里面能放8个比特位，就好比同学们住的8人间，每个人是一个比特位。

每个内存单元也都有一个编号（这个编号就相当于宿舍房间的门牌号），有了这个内存单元的编号，CPU就可以快速找到一个内存空间。

生活中我们把门牌号也叫地址，在计算机我们把内存单元的编号也称为地址。C语言中给地址起了新的名字叫：指针。

因此我们可以理解为：

内存单元的编号地址指针

1.2 究竟该如何理解编址

CPU访问内存中 的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址(就如同宿舍很多，需要给宿舍编号一样)。

计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。

钢琴、吉他 上面都没有写上"哆啦咪发索拉西多"这样的信息，但演奏者照样能顾准确找到每一个琴弦的每一个位置，这是为何？因为制造商已经在乐器硬件层面上设计好了，并且所有的演奏者都知道。本质是一种约定出来的共识！

硬件编址也是如此

具体看下图：

首先，我们必须理解，计算机内是很多的硬件单元，而硬件单元是互相协同工作的。所谓的协同，至少相互之间要能够进行那个数据传递。

但是硬件与硬件之间是互相独立的，那么如何通信呢？答案很简单，用"线"连起来。

而CPU和内存之间也是有大量的数据交互，所以，两者必须也用线连起来。

不过，我们今天关心一组线，叫地址总线

我们可以简单理解，32位机器有32根地址总线，每根线只有两种状态，表示0或1，[电脉冲有无]，那么一根线，就能表示2中含义，2根线就能表示4种含义，依此类推。32根地址线，就能表示2^32种含义，每一种含义都代表一个地址。

地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过对应的数据，将数据再通过数据总线传入CPU内寄存器。

2. 指针变量和地址

2.1 取地址操作符 (&)

理解了内存和地址的关系，我们再回到C语言，在C语言中创建变量其实就是向内存申请空间，比如：

#include <stdio.h>
int main()
{
    
    
    int a = 10;
    return 0;
}

比如，上述代码就是创建了整型变量a,内存中申请了4个字节，用于存放整数10，其中每个字节都有地址，上图4个字节的地址分别是：

1.0x006FFD6C  
2.0x006FFD6D 
3.0x006FFD6E  
4.0x006FFD6F 

那我们如何得到a的地址呢？

这里就得学习一个操作符(&)-取地址操作符

#include <stdio.h>
int main()
{
    
    
    int a = 10;
    &a;//取出a的地址
    printf("%p\n", &a);
    return 0;
}

按照这个画图的例子，会打印处理：006FFD6C

&a取出的是a所占4个字节中地址较小的字节的地址。

虽然整型变量占用4个字节，但我们只要知道了第一个字节地址，就可以顺藤摸瓜地访问到4个字节的数据也是可行的。

2.2 指针变量和解引用操作符(*)

2.2.1 指针变量

我们通过取地址操作符(&)拿到的地址是一个数值，比如：0x006FFD6C，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址值存放在哪里呢？答案是：指针变量中。

比如：

#include <stdio.h>
int main()
{
    
    
    int a = 10;
    int* pa = &a;//取出a的地址并存储到指针变量pa中
    return 0;
}

指针变量也是一种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。

2.2.2 如何拆解指针类型

我们看到pa的类型是int*,我们该如何理解指针的类型呢？

int a = 10;
int * pa = &a;

这里pa左边写的是**int*,*,是在说明pa是指针变量，而前面的int是在说明pa指向的是整型(int)类型的对象。

具体解释看下图：

那如果有一个char类型的变量ch，ch的地址，要放在什么类型的指针变量中呢？

char ch = 'w';
pc = &ch;//pc 的类型怎么写呢？

仔细思考的话，我们也可以写出如下代码:

char ch='w';
char *pc=&ch

前面的*表示pc是指针，而前面的char指的是pc所指向的是ch变量，也就是char类型。

同理，其他类型的变量的地址如果想要放在指针变量中，也是按照上述操作就可以啦！

由此可见，指针变量就是用来存放地址的值，存放在指针变量的值，都会被当成地址来使用。

2.2.3 解引用操作符

我们将地址保存起来，未来是要使用的，那怎么使用呢？

在现实生活中，我们使用地址要找到一个房间，在房间里可以拿去或者存放物品。

C语言中其实也是一样的，我们只要拿到了地址(指针)，就可以通过地址(指针)指向的对象，所以我们这里必须学习一个操作符叫解引用操作符(*)。

1 #include<stdio.h>
2 int main()
3 {
    
    
4     int a = 100;
5     int* pa = &a;
6     *pa = 0;
7     return 0;
8 }

上面代码中第6行就使用了解引用操作符，*pa的意思就是通过pa中存放的地址，找到指向的空间，pa其实就是a变量了；**所以pa=0,这个操作符就是把变量a改为0了。

有人肯定在想，这里如果目的就是把a改为0的话，写成a=0,不就行了吗？为啥非要使用指针呢？

其实这里是把a的修改交给了pa操作，这样对a的修改，就会多了一种途径，写代码也会更加灵活，我们后期就会慢慢理解这种改法了。

2.3 指针变量的大小

在前面的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换为数字信号，是1或者0，那我们把32根地址线产生的2进制序列当做一个地址，那么一个地址就是32个bit位，需要4个字节才能存储。

如果是指针变量是用来存放地址的，那么指针变的大小就是得4个字节的空间才可以。

同理64位机器，假设有64根地址线，一个地址就是64个二进制位组成的二进制序列，存储起来就需要8个字节的空间，指针变的大小就是8个字节。

具体看如下代码所示：

#include <stdio.h>
//指针变量的大小取决于地址的大小
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
int main()
{
    
    
    printf("%zd\n", sizeof(char *));
    printf("%zd\n", sizeof(short *));
    printf("%zd\n", sizeof(int *));
    printf("%zd\n", sizeof(double *));
    return 0;
}

下面我们分别看一下32位和64位指针变量大小的运行结果：

结论：

• 32位平台下地址是32位bit位，指针变量大小是4个字节
• 64位平台下地址是64个bit位，指针变量大小是8个字节
• 需要注意的是，指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

3.指针变量的类型和意义

前面我们知道指针变量的大小和类型无关，只要是指针变量，在同一平台，大小都是一样的，为什么还要有各种各样的指针类型呢？

其实指针类型是有特殊意义的，我们接下来继续学习。

3.1 指针的解引用

对此，下面2段代码，我们主要在调试时观察内存的变化。

//代码1
#include <stdio.h>
int main()
{
    
    
    int n = 0x11223344;
    int *pi = &n;
    *pi = 0;
    return 0;
}

//代码2
#include <stdio.h>
int main()
{
    
    
    int n = 0x11223344;
    char *pc = (char *)&n;
    *pc = 0;
    return 0;
}

通过调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的前两个字节改为0。

因此我们可以得出以下结论:
指针的类型决定了，对指针解引用的时候有多大的权限(一次能操作几个字节)。
比如：char星的指针解引用就只能访问一个字节，short星的指针解引用就只能访问前两个字节。而int的指针的解引用就能访问四个字节。
![](https://img-blog.csdnimg.cn/img_convert/e20d86e2fbdf471b0b21bd6f657c3ed8.png

3.2 指针±整数

我们先看一段代码，调试观察地址的变化~

#include <stdio.h>
int main()
{
    
    
	int n = 10;
	char* pc = (char*)&n;
	int* pi = &n;
	printf("%p\n", &n);
	printf("%p\n", pc);
	printf("%p\n", pc + 1);
	printf("%p\n", pi);
	printf("%p\n", pi + 1);
	return 0;
}

代码运行的结果如下：

我们可以看出，char星类型的指针变量+1跳过1个字节，而int*类型的指针变量+1跳过了4个字节。

由此可见，这就是指针变量的类型带来的变化。

结论：指针的类型决定了指针向前或者向后走一步有多大（距离）。相当于指针的步长。

4.const修饰指针

4.1 const修饰变量

我们都知道，变量是可以修改的 ，如果把变量的地址交给一个指针变量，通过指针变量也可以修改这个变量，但是如果我们希望一个变量加上一些限制，不能被修改，怎么做呢？那么这时候我们就需要用上C语言的关键字const啦!

首先我们来看一下下面这几行代码：

#include <stdio.h>
int main()
{
    
    
	const int m = 100;
	m = 20;//m是可以修改的吗？
	printf("%d\n", m);
	return 0;
}

那么它这个代码是否能运行呢？我们用vs来运行一下它~

由图中，我们可以得知，VS在413行那里已经有报错提示了，那么也以为着上述代码中m是不能被修改的，其实m本质是变量，只不过被const修饰后，在语法上加了限制，只要我们再代码中对m进行修改，那它就不符合语法规则，就会报错，这样致使没法直接修改m。

但是如果我们绕过m,使用m的地址，去修改m就能做到了，虽然这样做是在打破语法规则。

比方说：我们可以看一下下面这几行代码：

#include <stdio.h>
int main()
{
    
    
    const int m = 0;
    printf("m = %d\n", m);
    int*p = &m;
    *p = 20;
    printf("m = %d\n", m);
    return 0;
}

输出结果：

从这里我们可以看到这里一个确实修改了，但是我们仔细思考一下，为什么m要被const修饰呢？就是为了m不能被修改，但如果p通过m的地址就能修改m,这样就打破了const的限制，这是不合理的，所以应该让p拿到m的地址也不能修改m,那接下来怎么做呢？

4.2 const修饰指针变量

我们来看下面代码，来分析~

#include <stdio.h>
//代码1
void test1()
{
    
    
	int n = 10;
	int m = 20;
    int *p = &n;
    *p = 20;//ok?
    p = &m; //ok?
}
void test2()
{
    
    
    //代码2
    int n = 10;
    int m = 20;
    const int* p = &n;
    *p = 20;//ok?
    p = &m; //ok?
}
void test3()
{
    
    
    int n = 10;
    int m = 20;
    int *const p = &n;
    *p = 20; //ok?
    p = &m; //ok?
}
void test4()
{
    
    
    int n = 10;
    int m = 20;
    int const * const p = &n;
    *p = 20; //ok?
    p = &m; //ok?
}
int main()
{
    
    
    //测试无const修饰的情况
    test1();
    //测试const放在*的左边情况
    test2();
    //测试const放在*的右边情况
    test3();
    //测试*的左右两边都有const
    test4();
    return 0;
}

我们先看看const放在*的左边情况，会出现什么报错情况？

通过vs的425行报错信息我们可以得知，当const放在int的左边，修饰的是*p,限制的是不能通过p进行解引用操作来改变所指向n本身的内容,而p本身是可以改的

而如果是const放在*的右边，那又会出现什么报错情况呢？

通过vs的426行的报错信息我们可以得知，当const放在*的右边，修饰的是指针变量本身，就是说指针变量p的内容不能修改，而p所指向的内容，是可以修改的。

那么如果是const分别放在*的左边和右边，那这样会发生什么报错情况呢？

通过vs的425和426行报错信息我们可以得知，如果*的左边和右边都有const来修饰的话，那么指针变量本身p和p所指向的内容都是不能改变的，相当于被摁的死死的。

因此，我们可以得出下面的结论：

const修饰指针变量的时候

• Const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针本身的内容可变。
• Const如果放在*右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

5.指针运算

指针的基本运算有三种，分别是：

• 指针±整数
• 指针-指针
• 指针的关系运算

5.1 指针±整数

我们都知道，通常我们打印数组里面元素的话，我们可以通过访问它下标的方式进行打印，如下图所示：

那如果我们要用指针的方式来打印数组里面元素的话，我们该怎么做呢？

我们可以这么想，因为数组在内存中是连续存放的，只要知道第一个元素的地址，就能顺藤摸瓜地找到后面的所有元素。

1 int arr[10]={
    
    1,2,3,4,5,6,7,8,9,10}

具体代码实现如下所示：

#include <stdio.h>
//指针+- 整数
int main()
{
    
    
    int arr[10] = {
    
    1,2,3,4,5,6,7,8,9,10};
    int *p = &arr[0];
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(i=0; i<sz; i++)
    {
    
    
    	printf("%d ", *(p+i));//p+i 这里就是指针+整数
    }
    return 0;
}

我们分析一下上面这几行代码，首先这行代码int *p=&arr[0],我们是首先将数组第一个元素的地址放到整型指针p里面去。

而for循环中的*(p+i)又是什么意思呢？

我们通过调试可以得知，数组中每个元素都是整型，并且都是连续存放的 且占4个字节。

我们比方说这个int *p这个指针变量拿到的是首元素地址0x008FFAF4,因为我们前面讲过&arr[0]取出的是arr[0]所占4个字节中地址较小的字节的地址。

而如果我们对它这个地址加1的话，会怎么样呢？通过分析可以得知，由于这个P是一个int*类型的指针，因此如果它加一的话，会直接跳过4个字节，由于它是一个整型指针，因此它加1的话，是直接跳过一个整型元素的，也就是说跳过4个字节。而由上图，我们也能得知，这里p+i也相当拿到&arr[i]元素的地址。

因此我们可以推导出这个式子:p+n=n*sizeof(int)

因为p是个整形指针，因此p+n就是跳过n*sizeof(int)的字节。

但是我们要通过这个地址找到我们想要找的元素怎么办。我们可以对(p+i)进行前面进行解引用*操作，那么这样我们就能拿到地址所指向对应元素的值。

运行结果如下所示：

当然这个for循环里面我们也可以让i循环十次，然后对*p进行解引用操作，然后再进行p++,而p++的本质就是p=p+1。
其实跟上面代码一样，把p加上一个整型元素的赋给p，然后再通过解引用操作，找到地址所指向元素的值，就这样循环10次，我们也就能打印数组的元素出来。

具体代码和运行用例如下图所示：

同样地，我们再给大家举一个字符指针的例子，具体看如下代码：

#include <stdio.h>
int main(){
    
    

	char str[]="abcdef";
	char *pc=&str[0];
	while(*pc!='\0'){
    
    
		printf("%c",*pc);
		pc++;
	}

	return 0;
}

比方说，我这里定义了一个str的字符数组，str数组里面存的是abcdef和\0,那同样地，我们首先把str[0]首元素的地址交给星pc,然后因为\0是字符串的结束标志。

那么我们就可以把循环条件写成*pc！=‘0’,那么这样我们就能把\0前面的abcdef字符全部打印出来，每次循环都会对它进行解引用操作，找到所对应的元素进行打印，然后pc++,把pc加上一个char类型的指针赋给pc,直到把f这个字符打印出来后，然后pc++，指向的是\0这个字符，但是\0是=‘\0’,显然是不符合循环条件，那么它就会跳出while循环。

5.2 指针-指针

我们先来看一下下面这行代码，大家看看运行结果是多少呢？

#include <stdio.h>
int main(){
    
    

	int arr[10]={
    
    0};
	int ret=&arr[9]-&arr[0];
	printf("%d\n",ret);
	return 0;
}

我们来看一下运行结果吧~

那如果说我把461行的代码改写成int ret=&arr[0]-&arr[9];又会出现什么结果呢？我们运行试试看。

结果是-9，那么我们可以得出以下结论：

指针-指针(地址-地址)得到的值的绝对值是指针和指针之间元素个数。

并且还有一个前提条件：两块指针都是指向同一块空间的。

为什么这么说呢？

我们来看一下，假设我定义了一个一个char类型数组ch,然后用&arr[9]-&ch[5]的值赋给ret,让它来计算这两个数组之间的元素个数有多少。

我们来看一下下面这几行代码：

#include <stdio.h>
int main(){
    
    

	int arr[10]={
    
    0};
	char ch[7]={
    
    0};
	int ret=&arr[9]-&ch[5];
	printf("%d\n",ret);
	return 0;
}

我们首先先画个图看一下arr[9]和ch[5]的地址位置在哪里。

虽然这两个数组的地址我都能找到，但是它们之间有多少个元素个数这是不确定的,其次,它们这两个数组的元素个数是按int类型来算，还是用char类型来算？这不就是胡扯吗。因此这两个计算是没有意义的。

当我们有了这个概念后，那么指针-指针有什么用吗？那么我们再给大家举个例子？

我们首先先给大家看一下下面这几行代码~

#include <stdio.h>
#include <string.h>

int main(){
    
    
	char arr[]="abcdef";
	int lens=strlen(arr);
	printf("%d\n",lens);
	return 0;
}

从上面这几行代码我们可以得知:
strlen计算的是字符串长度。而在这里，strlen计算的是arr数组的长度，由于arr数组里面存放的是字符串，而\0是字符串的结束标志，因此strlen会把\0之前的字符计算起来，那么计算结果就是6。

我们也可以在函数官网看一下strlen函数的介绍~

大家如果有兴趣的可以点击网址查一下这个该函数的用法：
C/C++函数官网

那么我们如果要自己用指针的方式模拟实现这个strlen函数，该怎么做呢？
这个代码我们可以这么写：

#include <stdio.h>
#include <string.h>

int my_strlen(char* str) {
    
    
	int count = 0;
	while (*str != '\0') {
    
    
		count++;
		str++;
	}
	return count;
}

int main(){
    
    
	char arr[] = "abcdef";
	int lens =my_strlen(arr);
	printf("%d\n", lens);
	return 0;
}

首先呢，我们看一下下面这行代码

int lens =my_strlen(arr);

这个代码本质就是把字符a给传到my_strlen函数里面去，为什么这么说呢？我们看下图:

从图中，我们可以看出：数组名就是数组首元素的地址。所以my_strlen函数形参部分我们就能拿指针形式char*str来接收它，这样我们就能把首元素a的地址传过去。

当我们把a的地址传到str里面去，我们可以定义一个变量count,然后在while循环里面加上*str!='0’这个条件。但是星str不能总是指向’a’的地址。
因此我们要在循环体里面加上str++这条语句,直到当str指向‘\0’，也就是说与‘\0’相等后，便跳出while循环，那么到时return count就相当于返回的是count的个数出来。

下面是这个代码的运行结果：

当然，这个代码还是有待修改的，比方改成下面这种：

#include <stdio.h>
#include <string.h>

int my_strlen(char* str) {
    
    
	char* pc =str;
	while (*str != 0)
		str++;
	return str - pc;
}

int main() {
    
    
	char arr[] = "abcdef";
	int lens =my_strlen(arr);
	printf("%d\n", lens);
	return 0;
}

在上面函数my_strlen部分，我们首先用char*str接收a的元素，然后在函数体内，我们再用char 星pc来接收str元素a,以此作为它的起始点标记，然后在while循环内，只要星str!=‘\0’,它都会不断加1，直到当str指向‘\0’，它就会跳出循环体。
又因为pc和str两个指针变量都是属于char星类型，因此它们两个相减得到的是中间间隔元素的个数。

下面是动图演示，大家可以看一下~

代码运行结果如下所示：

5.3 指针的关系运算

我们来看一下这个代码：

//指针的关系运算
#include <stdio.h>
int main()
{
    
    
    int arr[10] = {
    
    1,2,3,4,5,6,7,8,9,10};
    int *p = &arr[0];
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    while(p<arr+sz) //指针的大小比较
    {
    
    
        printf("%d ", *p);
        p++;
    }
    return 0;
}

从这个代码中，我们可以看出，我们先用*p来接收数组首元素&arr[0]的地址，然后通过这行代码sizeof(arr)/sizof(arr[0])计算出数组的元素个数出来，然后把它的元素个数赋给sz这个变量，接着在while循环条件中，我们把条件写成(p<arr+sz)。
可能有人会有疑问，为什么要这么写呢？

实际上我们可以看下图：

从图中我们可以得知，因为arr是数组名，它是数组首元素的地址，那么我们可以得知指针变量p和arr数组都是指向的是数组首元素的地址，因为数组的首元素下标是0嘛，然后数组的最后一个元素下标是9嘛，那么最后一个元素的下标也就是sz嘛，也就是10。
所以它那个地址也就相当于起始位置的地址+10,跳过10个元素就能指向它了。又因为数组名是数组首元素的地址。因此我们就可以把循环条件写成while(p<arr+sz)，然后在循环体内，我们先对p里面的地址进行解引用操作，找到地址所指向的对象,然后进行p++,因为p本身就是个整型指针，所以每次p+1也就是跳过一个整型。直到p的地址大于等于arr+sz的地址，那么它将会跳出循环。

那么我们来看一下这个代码的运行结果吧~

事实上我们可以把91行的代码改成这样：

int *p=arr;

因为数组名是数组首元素的地址，所以实际上这两个代码运行结果都是一样的，我们不妨来看一下~

好啦，今天的内容就分享到这里

如果觉得博主讲得不错的话，

欢迎一键三连支持一下

谢谢！！！！！！