【指针的深刻理解】

如何看待下面代码中的a变量?

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

	//同样的一个a，在不同的表达式中，名称是一样的，但是含义是完全不同的！
	a = 10;//使用的是a的空间：左值
	int b = a; //使用的是a的内容：右值
	return 0;
}

        在C语言中，表达式的值可以分为左值和右值。

        左值指的是可以出现在赋值语句的左边的表达式，它代表一个可修改的内存地址。比如变量名、数组名、指针等，它们都可以被赋值，因此是左值。例如，`a`、`b`、`array[0]`、`&x`等都是左值。

        右值指的是可以出现在赋值语句的右边的表达式，它代表一个常量或一个值。比如字面量、函数返回值等都是右值。右值通常不能被赋值，因此不能出现在赋值语句的左边。例如，`10`、`"hello"`、`x + y`、`func()`等都是右值。

结论：同样一个a变量，在不同的应用场景中，a本身的含义是不同的。

1.重新理解变量。

定义一个变量，本质是在内存中根据类型来进行开辟空间。有了空间，就必须具有地址来标识空间，来方便CPU进行寻址。有了空间，就可以把数据保存起来。所以，目前我们先讨论变量的空间和内容这两个概念。

2. 什么是指针？

指针就是地址！那么地址本质是什么呢？地址是数据，那么数据可不可以被保存在变量空间里面呢？当然可以。

3. 有没有指针变量这个概念？

保存指针(地址)数据的变量就叫做指针变量。

4. 指针和指针变量又有何不同？我们口语中的"定义一个指针"究竟是什么意思?我们该如何理解这种说法？

严格意义上，指针和指针变量是不同的，指针就是地址值，而指针变量是C中的变量，要在特定区域开辟空间，要用来保存地址数据，还可以被取地址。(先分开) 但是，我们经常在口语化表达的时候，又经常将这两个概念混合，具体原因无从考证，不过个人认为与最早的C资料(书，文档之类)的翻译有关。然后，书与书之间互相借鉴，形成了这样的说法。

#include<stdio.h>
int main()
{
	int* p = NULL;
	//指针就是地址
    //指针变量本质就是变量，然后里面保存的是地址(指针)值
    //指针变量：空间(左值)+内容(右值：地址)

	p = (int*)0x1234;//p变量的空间：左值
	int* q = p;//p变量的内容：右值，就是刚刚的0x00001234，此时指针==指针变量

    (int*)0x11223344;//指针?还是指针变量? --- 指针
    10;//整数10?还是整数变量? --- 整数10
	return 0;
}

小练习一下

#include<stdio.h>
int main()
{
	int a = 10;
	int* p = &a;

	p = 10; //什么意思? --- p指的是空间：左值 --- p-->指针变量
	int* q = p; //什么意思? --- p指的是内容：右值 --- p-->指针

	*p = 10; //什么意思？--- *p指的是空间：左值 --- *p-->整型变量
	int b = *p; //什么意思? --- *p指的是内容：右值 --- *p-->整型值
	return 0;
}

结论：指针就是地址，指针变量是一个变量，变量内部保存指针(地址)数据。

为什么要有指针？

为何每间宿舍都要有门牌号呢？

门牌号可以帮助学生快速准确地找到自己的宿舍，能够极大地提高查找效率。

类比到计算机中

CPU在内存中寻址的基本单位是多大？ --- 字节
在32位机器下，最多能够识别多大的物理内存？--- 32位地址总线最多只能寻址2的32次方个不同的地址，而每个地址对应一个字节，因此可识别的物理内存总大小为2的32次方字节，即4GB。
既然CPU寻址按照字节寻址，但是内存又很大，所以，内存可以看做众多字节的集合

其中，每个内存字节空间，相当于一个学生宿舍，字节空间里面能放8个比特位,就好比同学们住的八人间，每个人是一个比特位。每间宿舍都有门牌号就等价于每个字节空间对应的地址，即该空间对应的指针。

那么，为何要存在指针呢？

为了CPU寻址的效率。

如果没有，该怎么找在字节空间中的数据呢?

CPU只能遍历内存寻找数据。

#include<stdio.h>
int main()
{
	*((int*)0x11223344) = 10;//不方便
	
	//随后指针变量诞生了
	int* p = (int*)0x11223344;
	*p = 10;//简洁明了
	return 0;
}

究竟该如何理解编址

首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要互相协同工作的。所谓的协同，至少相互之间要能够进行数据传递。
但是硬件与硬件之间是互相独立的，那么如何通信呢？答案很简单，用"线"连起来。
而CPU和内存之间也是有大量的数据交互的，所以，两者必须也用线连起来。
不过，我们今天关心一组线，叫做地址总线。
CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址(就如同宿舍很多，需要给宿舍编号一样)
计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。
钢琴吉他上面没有写上“都瑞咪发嗦啦”这样的信息，但演奏者照样能够准确找到每一个琴弦的每一个位置，这是为何？因为制造商已经在乐器硬件层面上设计好了，并且所有的演奏者都知道。本质是一种约定出来的共识！
硬件编址也是如此
我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表示0,1【电脉冲有无】，那么一根线，就能表示2中含义，2根线就能表示4中含义，依次类推。32根地址线，就能表示2^32中含义，每一种含义都代表一个地址。
地址信息被下达给内存，在内存内部，就可以找到改地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

指针的内存布局

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

这里定义了几个变量？在哪里定义的？
一个整形，有4个字节，那么应该有4个地址！那么&a取了哪一个地址?那么如何全部访问这4个字节呢？
如何正确的画出指针指向图？

这里定义了两个变量：一个整型变量a和一个指向整型变量的指针变量p。这两个变量定义在main函数的局部作用域中。
变量a在定义时被赋值为0xaabbccdd，占用4个字节的内存空间。指针变量p被定义为一个指向整型变量的指针，并被初始化为a的地址。因此，p指向了变量a的地址，即p所指向的内存单元存储了变量a的值0xaabbccdd。由于a占用4个字节的内存空间，因此可以通过指针p访问a的每一个字节。例如，使用*(p+0)访问a的第一个字节，使用*(p+1)访问a的第二个字节，以此类推，最终可以访问到a的全部4个字节。
这个图展示了指针p指向变量a的地址，即指针p存储了变量a的地址0xaabbccdd。

指针解引用

#include<stdio.h>
int main()
{
	int a = 10;
	int* p = &a;

	int b = *p;
	*p = 20;
	return 0;
}

*p完整理解是，取出p中的地址，访问该地址指向的内存单元(空间或者内容)（其实通过指针变量访问，本质是一种间接寻址的方式）
口诀：对指针解引用，就是指针指向的目标。所以*p,就是a。

那在int b = *p;中我们知道*是一个操纵符，*p就是一个表达式，那么此时的p是左值还是右值呢？？？

#include<stdio.h>
int main()
{
	*(double*)0 = 10.0;

	double* p = NULL;
	*p = 10.0;

	return 0;
}

结论：p指的是内容：右值

*p = NULL 和 p = NULL的区别

`*p = NULL` 表示将指针p所指向的内存单元的值设置为NULL。这样做有时候可以用来释放指针所指向的内存，或者表示指针不再指向任何有效的内存地址。
而 `p = NULL` 表示将指针p本身的值设置为NULL。这种情况下，指针p不再指向任何有效的内存地址。

所以，两者的区别在于作用对象不同。

`*p = NULL` 是对指针p所指向的内存单元进行操作，而`p = NULL`是对指针p本身进行操作。

如何将数值存储到指定的内存地址？

知道了指针的本质就是地址，地址就是数据，那么我们可以直接通过地址数据对变量进行访问吗？
大部分技术书，一定是落后于行业的。这本书也是，目前主流的编译器和操作系统，为了安全，已经有了很多内存保护的机制。我们目前的win和Linux都有栈随机化这样的机制来方式黑客对用户数据地址进行预测。
经过试验，目前vs2013和Centos7上，使用C语言定义的局部变量，在每次运行的时候，地址都是不同的。经过试验发现，定义全局变量，每次更改代码，地址也会发生变化。所以这个实验没法正确做出来，但是程序崩溃，也能说明问题。

何为栈随机化

局部变量(在栈上开辟)在每次创建的时候其地址是随机变化的。

#include<stdio.h>
int main()
{
	int a = 10;//假设a变量的地址是0x12345678，访问a变量，还可以直接通过指针方式进行访问
	printf("%d\n", *(int*)0x12345678); //本质是一种直接寻址的方式
	*(int*)0x12345678 = 100; //本质是一种直接寻址的方式

	int* p = &a;
	*p = 100;
	//所以，C语言通过 int*p = &a;这种指针变量的间接寻址方式，访问目标数据有什么好处呢？
	//不用关心a变量的地址是什么，只需知道p变量里面放的是a的地址就行
	return 0;
}

编译器的bug

#include<stdio.h>
int main()
{
	int* p = NULL;
	p = (int*)&p;

	*p = 10;
	p = (int*)20;
	return 0;
}

        这是一段 C 代码，它的主要作用是演示指针的使用和指针类型的转换。

int* p = NULL;
p = (int*)&p;

        这两行代码定义一个指向整型变量的指针 p，并将它初始化为 NULL，然后将指针 p 的地址强制转换为一个指向指针变量的指针，并将转换结果赋值给 p。这样做的效果是将 p 指向自己的地址。

*p = 10;

        这一行代码将指针 p 的值设置为 10。由于 p 指向的是自己的地址，因此这个操作相当于让程序尝试修改自己的指针地址中存储的值。这是一种非常危险的行为，可能会导致程序崩溃或者出现其他严重问题。

p = (int*)20;

        这一行代码将指针 p 的值设置为 20。由于指针 p 指向的地址已经被改变，因此原来存储在 p 中的指针地址会丢失，不再指向之前的变量。

        总的来说，这段代码是一种不安全的探索指针和类型转换的方式，不应该在实际的程序中使用。