深入理解指针(1)

在之前我们学习了许多c语言的基础知识，让我们初步了解了c语言，接下来将来到c语言中一个重点的知识章节--指针，学习完指针后将会让我们对c语言有更深入的理解，接下来就开始指针的讲解

1.内存与地址

1.指针

在了解内存与地址前，先来看一个生活中的案例
我们都知道当到一个陌生的楼房里时，，如果这个楼房很大通过门牌号去查找将会是一个快速找到的方法，如果得到房间号，就可以快速的找房间

在生活中有了门牌号就可以快速找到房间，大大提升了效率

如果把上面的例子对照到计算机中，又是怎么样呢？
我们知道在计算机中都有内存，可能是4G/8G/16G等等，但无论是多大的内存都是一份相当大的空间，而数据又是放在内存当中的，我们知道计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中

那在内存这么大的空间里，数据是依据什么来找到的呢？那那些内存空间如何高效的管理呢？
在生活当中把楼房划分成一个个房间，其实在内存当中也是相同的道理，为了更高效的对内存进行使用和管理，其实也是把内存划分为⼀个个的内存单元，每个内存单元的大小取1个字节，我们可以理解为内存像楼房一样被划分成了许多房间，每个房间就是一个内存单元

有的读者会提出1个字节是什么？
这时我们就要知道计算机中的单位

bit - ⽐特位
Byte - 字节         1Byte=8Bit
KB                       1kB=1024Byte
MB                      1MB=1024KB
GB                       1GB=1024MB        
TB                        1TB=1024GB
PB                        1PB=1024TB
 

其中1比特在内存中可以存储1个二进制位中的1或者0

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

为了CPU能更高效调用内存，就如给楼房的房间编号一样，内存中每个内存单元也有不同的编号，这也就是内存单元的地址，在c语言中给这些地址起了新的名字：指针

在此可以理解为：内存单元编号=地址=指针

2.如何理解地址的产生

通过以上的讲解我们知道CPU是通过地址来获取内存中的数据，再将处理后的数据存放在内存当中，那么该过程中内存单元的地址是怎么传送的呢？
首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要互相协同工作的。但是硬件与硬件之间是互相独立的，要使它们之间建立通信这就需要用"线"连起来

CPU和内存之间也是有大量的数据交互的，所以，两者必须也用线连起来。在这两者之间有地址总线，控制总线，数据总线。在此我们需要了解的是地址总线

 CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节
很多，所以需要给内存进行编址。且计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。
我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表示0,1【电脉冲有无】，那么⼀根线，就能表示2种含义，2根线就能表示4种含义，依次类推。32根地址线，就能表示2^32种含义，每⼀种含义都代表⼀个地址。地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

2.指针变量与地址

1.取地址操作符（&）

int main()
{
	int a = 20;
	return 0;
}

变量创建的本质其实其实是在内存当中申请内存空间 例如以上代码就申请了4个字节的内存空间来存放20

以上就是20所存放的内存空间地址，但为什么显示的是14的地址呢？
其实这的14是用16进制表示，转换成10进制就是20

在以上还可以发现20所存放每个字节都有地址，再一次验证了在上文提到的每个内存单元都有地址

通过调试中发现内存中都没有关于a变量的信息，那么a是否对于编译器来说是没有作用的呢？
其实确实是这样的，对于编译器来说通过地址就可以找到内存空间，其实这个a是给我们程序员来看的，让我们知道使用a就是使用对应内存的4个字节

那我们如何才能拿到a的地址呢？
这时就要用到&--（取地址操作符），若在以上代码中加入&a，它的作用就是拿到变量的地址
注：这里的&是一个单目操作符，不要与按位与&混淆，按位与是一个双目操作符

我们知道变量是有4个地址，那么&之后取出的是哪个呢？ 

#include<stdio.h>
int main()
{
	int a = 20;
	printf("%p", &a);
	return 0;
}

这时就要用到%p这个占位符，%p的作用在printf函数中是打印出地址

运行程序就可以看到打印出的是a首个字节的地址，所以就可以知道&取出的是第一个字节的地址

2.指针变量和解引用操作符（*） 

1.指针变量 

 那如果想把变量的地址再存储到另一个变量当中应该如何操作呢？
如果这时将&a存放到pa变量中，那么这个变量的类型就是int*
pa是用来存放指针(地址)的，所以pa是指针变量
int*pa=&a 在这里pa左边写的是 int* ， * 是在说明pa是指针变量，而前面的 int 是在说明pa指向的是整型(int)类型的对象

2.解引用操作符

#include<stdio.h>
int main()
{
	int a = 20;
	int* pa=&a;
	return 0;
}

在以上代码中pa里存放着a的地址，那如果要通过pa来找到a应该怎么表示呢？
这时就要用到*（解引用操作符），*pa就是通过pa这个指针变量内存放的值找到a

例如要把a的值改成200，就可以通过*pa来实现

#include<stdio.h>
int main()
{
	int a = 20;
	int* pa=&a;
    *pa=200;
    printf("%d",a);
	return 0;
}

 这时有的读者会发问为什么要通过pa来将a的值修改，不是可以直接让a=200来实现吗？
在电视剧狂飙中当高齐强身份很高时有一些事就不再适合亲自出手，就比如说他对老墨说我想吃鱼，老墨就会帮他处理棘手的事    有时我们只是拿到了地址信息，这时就只能通过解引用指针变量的方式来改变变量的值

3.指针变量的大小

首先我们要知道指针变量是用来存放地址的，一个地址需要多大空间，那么指针变量就有多大

前面的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产生的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4个字节才能存储。
如果指针变量是用来存放地址的，那么指针变量的大小就得是4个字节的空间才可以。
同理64位机器，假设有64根地址线，⼀个地址就是64个二进制位组成的⼆进制序列，存储起来需要8个字节的空间，指针变量的大小就是8个字节

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

3. 指针变量类型的意义 

在以上讲解中我们知道了指针变量的大小与指针的类型无关，那么指针变量的类型有什么意义呢？
其实指针变量大小还是有意义的，接下来我们将学习其意义

1. 指针的解引用

在以上当中将a的值初始化为0x11223344，因为0x之后表示16进制的数，而一个16进制数又可以转化为4个二进制数，两个16进制数就可以转化为8个二进制数，所占空间就为1字节
这样就可以让存储这个数内存当中的每个内存单元都存放数

当讲&a放入int*类型的指针变量时，*pa会发现a所指向都每个内存单元都被被改成了0，*pa=0一次访问了4个字节

 在以上可以发现当讲指针变量pa的类型改为char*时，就*pa=0就只能将a当中的一个字节改为0，而且他的未改变，*pa=0一次访问了1个字节

 结论：指针的类型决定了，对指针解引用的时候有多大的权限（⼀次能操作几个字节）

2. 指针+-整数

由以上代码可见&n+与pa+1都使得地址增加了4，而pc+1只让地址增加了1 

 我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。
这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。

正如以上代码可以发现指针可以+1，那也可以-1。

 

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

3 void* 指针

在以上代码中可以看到当用char*类型的指针变量pc存储整形变量n的地址时，编译器会爆出以上警告

而当用void*来接收&n时候就不会出现警告

在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为无具体类型的指针（或者叫泛型指
针），这种类型的指针可以用来接受任意类型地址。 

注：void* 类型的指针也是有局限性的，不能直接进行指针的+-整数和解引用的运算。

那么 void* 类型的指针到底有什么用呢？
⼀般 void* 类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以
实现泛型编程的效果。使得⼀个函数来处理多种类型的数据，在之后深入会讲解。 

4. 关键字const 

1.const修饰变量

当对被const修饰后的变量重新赋值时，程序如以上一样就会报错

上述代码中n是不能被修改的，其实n本质是变量，所以被const修饰后就成为了常变量
只不过被const修饰后，在语法上加了限制，只要我们在代码中对n就行修改，就不符合语法规则，就报错，致使没法直接修改n。

2.const修饰指针变量

⼀般来讲const修饰指针变量，可以放在*的左边，也可以放在*的右边，但意义是不⼀样的

int main()
{
	int a = 20;
	const int*pa=&a;
	*pa = 0;
	return 0;
}

 

int main()
{
	int a = 20;
	 int const*pa=&a;
	*pa = 0;
	return 0;
}

 通过以上3个不同的代码可以发现
• const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。
但是指针变量本身的内容可变。
• const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指
向的内容，可以通过指针改变。

5. 指针运算

1.指针+- 整数

我们知道数组在内存当中是练习存放的，之前找数组元素都是通过数组下标来查找的，学习了指针后，这时就可以通过地址都方法找到数组元素 

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

 

2.指针-指针

我们首先要知道指针-指针的绝对值计算的是指针和指针之间的元素个数
注：前提条件是两个指针指向的是同一个内存空间

我们知道利用库函数strlen可以计算字符串的长度，那么如果不使用这个库函数，应该如何去计算呢？

#include<stdio.h>
size_t my_strlen(char*s)
{
	char* p = s;
	while (*p != '\0')
	{
		p++;
	}
	return p-s;
}



int main()
{
	char arr[] = "abcdef";//这里数组名表示首元素的地址
	
	printf("%zd", my_strlen(arr));

	return 0;
}

因为字符串结束的标志是\0,所以通过\0之前的指针-第一个字符的指针就得出这个字符串的长度

这时有的读者会想那是否有指针+指针呢？
其实这就和日期一样，日期-日期可计算出之间差的天数，日期+日期是没有意义的，指针也同理

3.指针的关系运算

指针之间的关系运算其实就是对指针之间的大小进行比较

例如以上打印数组也可以用关系运算来实现代码

#include<stdio.h>

int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
   int* p = &arr[0];
   int sz = sizeof(arr) / sizeof(arr[0]);
   while(p<arr+sz)
  {
	printf("%d ", *p);
	p++;
  }
	return 0;
}

6.野指针

1.野指针形成原因

1. 指针未初始化

局部变量指针未初始化，默认为随机值

 

 2. 指针越界访问

#include <stdio.h>
int main()
{
 int arr[10] = {0};
 int *p = &arr[0];
 int i = 0;
 for(i=0; i<=10; i++)
 {
 //当指针指向的范围超出数组arr的范围时，p就是野指针
 *(p++) = i;
 }
 return 0;
}

以上代码中数组大小初始化为10，而arr[10]已经不在arr的范围内

3. 指针指向的空间释放

#include <stdio.h>
int* test()
{
 int n = 100;
 return &n;
}

int main()
{
 int*p = test();

printf("%d\n", *p);
return 0;
}

我们知道局部变量在出作用域后就会销毁，所以在以上代码中出test函数后通过地址就无法在找到n

2.如何规避野指针

1.指针初始化

如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL.

#include <stdio.h>
int main()
{
int num = 10;
int*p1 = &num;
int*p2 = NULL;
return 0;
}

例如以上代码我们知道p2为野指针就给它初始化赋值NULL，这样再之后就知道p2是野指针就不要去访问 如果解引用p2程序就会出现错误

2. 不要让指针越界访问

⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问

3.指针变量不再使用时，及时置NULL，指针使用之前检查有效

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，当不再使用这个指针访问空间的
时候，我们可以把该指针置为NULL。  

我们可以把野指针想象成野狗，野狗放任不管是非常危险的，所以我们可以找一棵树把野狗拴起来，就相对安全了，给指针变量及时赋值为NULL，其实就类似把野狗栓起来，就是把野指针暂时管理起来。不过野狗即使拴起来我们也要绕着走，不能去挑逗野狗。对于指针也是，在使用指针之前要判断是不是野指针，不是才能使用

 

int main()
{
	int*pa=NULL;
    if(pa!=NULL)
   {
     *pa=100;
   }
	return 0;
}

正如以上代码一开始将pa置为空指针，用一个if语句使得pa不为空指针的时候再对pa解引用并赋值 

4. 避免返回局部变量的地址

就如以上提到的不要返回局部变量的地址，因为出作用域后局部变量会被销毁

7.传址调用与传值调用

在编写一些程序时，穿给函数的实参是数值时是无法解决问题的，例如要实现a，b两个变量的交换以下代码能实现吗？

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void Exchange(int x, int y)
{
	int z = x;
	x = y;
	y = z;
}

int main()
{
	int a = 10;
	int b = 20;
	Exchange(a, b);
	printf("a=%d b=%d", a, b);
	return 0;
}

 

这时就会发现a和b没有互换，这是为什么呢？我们调试程序看看 

 这时就会发现存放a的地址与存放x的地址不同，存放b的地址与存放y的地址不同，以上代码只是交换了x和y，但因为x和y是形参只是实参的一份临时拷贝，所以a和b没能实现交换
像以上Exchnage函数在使用的时候，是把变量本身直接传递给了函数，这种叫传值调用。

那要使用调用函数的方法实现两个数交换，正确方法是什么样的呢？

这时就要用到传址调用，将a和b的地址传给形参

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void Exchange(int*x, int*y)
{
	int z = *x;
	*x = *y;
	*y = z;
}

int main()
{
	int a = 10;
	int b = 20;
	Exchange(&a, &b);
	printf("a=%d b=%d", a, b);
	return 0;
}

通过以上调试发现存放a的地址与存放x的地址相同，存放b的地址与存放y的地址相同
以上就是利用传址调用

传址调用，可以让函数和主调函数之间建立真正的联系，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采用传值调用。如果函数内部要修改主调函数中的变量的值，就需要传址调用

以上就深入理解指针(1)的全部内容，希望看完以上内容你能有所收获，接下来还会继续更新指针的其他内容，未完待续....