内存和地址
内存
在讲内存和地址之前，我们想有个⽣活中的案例：
假设有⼀栋宿舍楼，把你放在楼⾥，楼上有100个房间，但是房间没有编号，你的⼀个朋友来找你玩，如果想找到你，就得挨个房⼦去找，这样效率很低，但是我们如果根据楼层和楼层的房间的情况，给每个房间编上号，如：
c
//一楼：101 102 103 ... ...
//二楼：201 202 203 ... ...
// ... ...有了房间号，如果你的朋友得到房间号，就可以快速的找房间，找到你。
如果把上⾯的例⼦对照到计算机中，⼜是怎么样呢？
我们知道计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如\何⾼效的管理呢？
其实也是把内存划分为⼀个个的内存单元，每个内存单元的⼤⼩取1个字节。
以我们可以理解为：
内存单元的编号地址指针。
补充：
计算机中常⻅的单位（补充）：
⼀个⽐特位可以存储⼀个2进制的位1或者0
8bit（比特）=1byte（字节）
编址
CU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置 ，⽽因为内存中字节很多，所以需要给内存进⾏编址 (就如同宿舍很多，需要给宿舍编号⼀样) 。
计算机中的编址，并不是把每个字节的地址记录下来 ，⽽是通过硬件设计完成的。即地址不是存起来的。。。
比如：钢琴、吉他上⾯没有写上"剁、来、咪、发、唆、拉、西"这样的信息，但演奏者照样能够准确找到每⼀个琴弦的每⼀个位置，这是为何？因为制造商已经在乐器硬件层⾯上设计好了，并且所有的演奏者都知道。本质是⼀种约定出来的共识！
⾸先，必须理解，计算机内是有很多的硬件单元，⽽硬件单元是要互相协同⼯作的。所谓的协同，⾄少相互之间要能够进⾏数据传递。
但是硬件与硬件之间是互相独⽴的，那么如何通信呢？答案很简单，⽤"线"连起来。
⽽CPU和内存之间也是有⼤量的数据交互 的，所以，两者必须也⽤线连起来。
不过，我们今天关⼼⼀组线，叫做地址总线。
硬件编址也是如此
我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表示0,1【电脉冲有无】，那么一根线，就能表示2种含义，2根线就能表示4种含义，依次类推。32根地址线，就能表示2^32种含义，每一种含义都代表一个地址。地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传入CPU内寄存器。
指针变量和地址
取地址操作符（&）
理解了内存和地址的关系，我们再回到C语言，在C语言中创建变量其实就是向内存申请空间 ，比如：
比如，上述的代码就是创建了整型变量a，内存中申请4个字节，用于存放整数10，其中每个字节都有地址（a的地址是第一个字节的地址），上图中4个字节的地址分别是：
那我们如何能得到a的地址呢？
这里就得学习一个操作符(&)-取地址操作符，如：
c
#include <stdio.h>
int main()
{
int a = 0x11223344;
printf("&a = %p", &a);// & 是取地址符号，用来取地址 &a 就是取a的地址
return 0;
}//输出结果：&a = 00000001000FF594（每一次运行结果可能不一样，因为 编译器 or 系统程序 给a取新的地址 ）&a取出的是a所占4个字节中地址较小的字节的地址。虽然整型变量占用4个字节，我们只要知道了第一个字节地址，顺藤摸瓜访问到4个字节的数据是可行的。
指针变量和解引用操作符（*）
指针变量
那我们通过取地址操作符(&)拿到的地址是一个数值，比如：0x006FFD70，这个数值有时候也是需要存储起来，方便后期再使用 的，那我们把这样的地址值存放在哪里呢？答案是：指针变量中。
比如：
c
#include <stdio.h>
int main()
{
int a = 0x11223344;
char ch = 'b';
//因为int char 后面有 "*" (即int* char*) 故pn pch 变成 指针变量(存放指针的变量)
//pn pch 存储的是变量n ch 的地址
int* pn = &a;
char* pch = &ch;
printf("&a = %p\n", pn);
printf("&ch = %p\n", pch);
return 0;
}//输出结果：&a = 010FFEC4
// &ch = 010FFEBB（每一次运行结果可能不一样，因为 编译器 or 系统程序 给a取新的地址 ）指针变量也是一种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为址。
如何拆解指针类型
我们看到pn的类型是int* ，我们该如何理解指针的类型呢？int* 是一个整体，pn就是int*类型。
*这里pa左边写的是int ， * 是在说明pa是指针变量，而前面的int 是在说明pa指向的是整型(int)类型的对象。**
解引用操作符
我们将地址保存起来，未来是要使用的，那怎么使用呢？
在现实生活中，我们使用地址要找到一个房间，在房间里可以拿去或者存放物品。
C语言中其实也是一样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这里必须学习一个操作符叫解引用操作符(*)。
c
#include <stdio.h>
int main()
{
int a = 10;
int* pn = &a;
//解引用操作符 -- 间接访问操作符
// *pn 就是 a
*pn=666;
printf("&a = %d\n", *pn);
printf("&a = %d\n", a);
return 0;
}//输出结果： &a = 666
// &a = 666上面代码中第7行就使用了解引用操作符， *pa 的意思就是通过pa中存放的地址，找到指向的空间，pa其实就是a变量了；所以pa = 0，这个操作符是把a改成了0。
c
// a&B 按位与操作符 （有两个操作数）
// & ---->>> 取地址操作符（有一个操作数）
// * ---->>> 解引用操作符指针变量的大小
前面的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产生的2进制序列当做一个地址，那么一个地址 就是32个bit位，需要4个字节才能存储。
如果指针变量是用来存放地址的，那么指针变的大小就得是4个字节的空间才可以。
同理64位机器，假设有64根地址线，一个地址就是64个二进制位组成的二进制序列，存储起来就需要8个字节的空间，指针变量的大小就是8个字节。
结论：
• 32位平台下地址是32个bit位，指针变量大小是4个字节
• 64位平台下地址是64个bit位，指针变量大小是8个字节
• 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。
指针变量类型的意义
指针变量的大小和类型无关 （指针变量只是存储地址的，只跟平台有关，与类型无关），只要是指针变量，在同一个平台下，大小都是一样的，为什么还要有各种各样的指针类型呢？
其实指针类型是有特殊意义的。
指针的解引用
直接提出结论：指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节）。
比如： char 的指针解引用就只能访问一个字节，而 int 的指针的解引用就能访问四个字节**。
指针±整数
我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。
这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。指针可以+1，那也可以-1。
结论：指针的类型决定了指针向前或者向后走一步有多大（距离）。
c
int * pi:
pi + 1 ---> 1 * sizeof(int)
pi + n ---> n * sizeof(int)
short * ps :
ps + 1 ---> 1 * sizeof(short)
ps + n ---> n * sizeof(short)void* 指针
在指针类型中有一种特殊的类型是void * 类型的，可以理解为无具体类型的指针 （或者叫泛型指针 ），这种类型的指针可以用来接受任意类型地址 。但是也有局限性， void 类型的指针不能直接进行指针的±整数和解引用的运算。 *
举例：
c
#include <stdio.h>
int main()
{
int n = 10;
//char * pi = &n; // --> 编译器发出警告 指针变量不兼容
void* pi = &n; // --> 编译器发出警告 指针变量兼容
//printf("%d\n", pi+1);//报错 -> "void *": 未知的大小
return 0;
}这里我们可以看到， void* 类型的指针可以接收不同类型的地址，但是无法直接进行指针运算。
那么void* 类型的指针到底有什么用呢？
一般void* 类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址 ，这样的设计可以实现泛型编程的效果。使得一个函数来处理多种类型的数据。
指针运算
指针的基本运算有三种，分别是：
• 指针± 整数
• 指针-指针
• 指针的关系运算
指针± 整数
因为数组在内存中是连续存放的，只要知道第一个元素的地址，顺藤摸瓜就能找到后面的所有元素。arr其实就是首元素的地址
c
#include <stdio.h>
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
int* p = &arr[0];
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);// 数组的大小
for (i = 0;i < sz;i++)
{
printf("%d ", *(p + i));// 指针的方式访问数组
}
return 0;
}//输出结果： 0 1 2 3 4 5 6 7 8 9注：（p+i）中，p后面加数字的字节大小取决于p的指针变量类型，int*时，后面加的数字大小是4个字节，char 时数字大小为1个字节。 如：
c
#include <stdio.h>
int main()
{
int arr1[10] = { 0,0,0,0,0,0,0,0,0,0 };
int* p1 = &arr1[0];
int i = 0;
int sz1 = sizeof(arr1) / sizeof(arr1[0]);// 数组的大小
for (i = 0;i < sz1;i++)
{
*(p1 + i) = i;
printf("%d ", *(p1 + i));// 指针的方式访问数组
}
printf("\n");
//==================================================================
char arr2[10] = { 'a','b','c','d','e','f','g','h','i','j'};
char* p2 = &arr2[0];
int sz2 = sizeof(arr2) / sizeof(arr2[0]);// 数组的大小
for (i = 0;i < sz2;i++)
{
*(p2 + i) = i;
printf("%d ", *(p2 + i));// 指针的方式访问数组
}
return 0;
}//输出结果:
// 0 1 2 3 4 5 6 7 8 9
// 0 1 2 3 4 5 6 7 8 9指针-指针
即 地址-地址
得到的是指针与指针之间的 元素个数即：
c
在这里插入代码片
因为地址是&arr[0]与&arr[9]是具有属性的，这里计算时，会考虑属性因素。
即具有int属性，则会自动计算4个字节为一个单位来计算；char属性，则会自动计算1个字节为一个单位来计算。。。
故void类型的指针无法计算。
指针之间的计算的前提是指向同一片空间。如数组，结构体 。。。
数组名就是首元素的地址(arr尾部右"\0"但是不是存储在arr尾部的)：
c
#include <stdio.h>
//指针-指针
#include <stdio.h>
int my_strlen(char* s)
{
char* p = s;
while (*p != '\0') //char arr数组尾部有一个'\0',但是不会直接储存在arr后面，访问arr后面会越界访问
p++;
return p - s;
}
int main()
{
char arr[] = "abcdefg";//仅限char类型时，有'\0'
printf("%d\n", my_strlen(arr));//指针名就是 数组的首元素地址 即数组的指针
return 0;
}//输出结果:
// 7这段代码优化后（加上断言）：
指针的关系运算
如：
c
#include <stdio.h>
int main()
{
int arr[10]= { 0,1,2,3,4,5,6,7,8,9 };
//使用指针的关系运算来打印数组内容
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);//10
while (p<&arr[sz])//用一下，没访问，就没有越界访问
{
printf("%d ", *p);
p++;
}
return 0;
}//输出结果:
// 0 1 2 3 4 5 6 7 8 9while (p<&arr[sz])就是运用 指针的关系运算（大小关系）
指针的使用和传址调用
strlen的模拟实现
库函数strlen的功能是求字符串长度，统计的是字符串中\0 之前的字符的个数。
参数str接收一个字符串的起始地址，然后开始统计字符串中\0 之前的字符个数，最终返回长度。
如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是\0 字符，计数器就+1，这样直到\0 就停止。
传值调用和传址调用
学习指针的目的是使用指针解决问题，那什么问题，非指针不可呢？
例如：写一个函数，交换两个整型变量的值
c
#include <stdio.h>
void swap(int x , int y)
{
int z = 0;
z = x;
x = y;
y = z;
}
//指针指向的空间释放
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：a=%d b=%d\n", a, b);
swap(&a, &b);
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}//输出结果:
//100 200
//交换前：a = 100 b = 200
//交换后：a = 100 b = 200当我们运行代码，结果如下：
c
//输出结果:
//100 200
//交换前：a = 100 b = 200
//交换后：a = 100 b = 200我们发现其实没产生交换的效果，这是为什么呢？
x,y,a,b都有独立的空间（地址），故互不影响。
我们发现在main函数内部，创建了a和b，a的地址是0x00cffdd0，b的地址是0x00cffdc4，在调用
Swap函数时，将a和b传递给了Swap1函数，在Swap函数内部创建了形参x和y接收a和b的值 ，但是x的地址是0x00cffcec，y的地址是0x00cffcf0，x和y确实接收到了a和b的值，不过x的地址和a的地址不一样，y的地址和b的地址不一样，相当于x和y是独立的空间，那么在Swap函数内部交换x和y的值，自然不会影响a和b，当Swap函数调用结束后回到main函数，a和b的没法交换。Swap函数在使用的时候，是把变量本身直接传递给了函数 ，这种调用函数的方式我们之前在函数的时候就知道了，这种叫传值调用。
结论：实参传递给形参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参。所以Swap是失败的了。
那怎么办呢？
我们现在要解决的就是当调用Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使用指针了，在main函数中将a和b的地址传递给Swap函数，Swap函数里边通过地址间接的操作main函数中的a和b，并达到交换的效果就好了。
c
#include <stdio.h>
void swap(int* a, int* b)
{
int c = *a;
*a = *b;
*b = c;
}
//指针指向的空间释放
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
printf("交换前：a=%d b=%d\n", a, b);
swap(&a, &b);
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}//输出结果:
//100 200
//交换前：a = 100 b = 200
//交换后：a = 200 b = 100我们可以看到实现成Swap的方式，顺利完成了任务，这里调用Swap函数的时候是将变量的地址传递给了函数，这种函数调用方式叫：传址调用。
传址调用，可以让函数和主调函数之间建立真正的联系 ，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采用传值调用。如果函数内部要修改主调函数中的变量的值，就需要传址调用。
传值调用 传内容
传址调用 传地址
完