C语言学习第008课——内存和指针
内存含义
- 存储器：计算机的组成中，用来存储程序和数据，辅助CPU进行运算处理的重要部分
- 内存：内部存储器，暂存程序/数据——掉电丢失，SRAM DRAM DDR DDR1 DDR2 DDR3
- 外存：外部存储器，长时间保存程序/数据——掉电不丢失，ROM ERRROM FLASH(NAND,NOR) 硬盘 光盘
内存是沟通CPU与硬盘的桥梁，暂时存放CPU中的运算数据，暂存与硬盘等外部存储器交换的数据
扩展：电脑的系统属性里面，显示的安装内存8G 这部分就可以分成8*1024*1024*1024个Byte，每个Byte都有自己的编号，
32位的系统，内存编号表示为无符号整形 unsigned int 占4个字节 最大代表2的32次方
64位的系统，内存编号表示为__int64 占8个字节 最大代表2的64次方
所以32位的系统如果安装上太大的内存条也没有特别大的提升，因为内存虽然大，但是可以编号的最大值卡死在了2的32次方上，剩余的内存无法编号便无法使用
物理存储器
就是实际存在的具体存储器芯片，比如主板上装插的内存条、显卡上的RAM芯片、各种适配卡上的RAM芯片和ROM芯片
存储地址空间
是对存储器编码的范围，我们在软件上常说的内存是指这一层含义
编码：对每一个物理存储单元（一个字节）分配一个号码
寻址：可以根据分配的号码，找到相应的存储单元，完成数据的读写
内存地址
将内存抽象成一个很大的一维字符数组
编码就是对内存的每一个字节分配一个32位或者64位的编号（与32位或者64位处理器有关）
这个内存编号我们称之为内存地址
内存中的每一个数据都会分配相应的地址
char 占一个字节分配一个地址
int 占4个字节，分配4个地址
float struct 函数 数组等
指针
内存地址打印：
int a = 0xaabbccdd;
printf("%p\n",&a);//打印结果：0x0059FE28
调试，根据内存地址查看值发现0x0059FE28 =》 dd
0x0059FE29 =》 cc
0x0059FE2a =》 bb
0x0059FE2b =》 aa
问题：发现aabbccdd在内存里面存储情况，随着内存地址编号增大，好像数据是倒过来存的，不是先存aa而是先存dd
这是因为windows做数据存储是采用小端对齐，也就是变量a中，aa是高位，dd是低位，所以aa存储在内存地址编号高的地方，dd存储在内存地址编号低的地方，一般情况下，比如做嵌入式开发，从Linux拿出来数据显示在windows中，就需要做大小端数据转换
定义指针变量存储变量地址：
int a = 10；
int* p; * 表示一种新的数据类型，就是指针数据类型
p = &a; 将a的地址赋值给p，p就是指向a的指针变量
printf("%p\n",&a);两个打印的结果是一样的
printf("%p\n",p);
在内存中，变量a被存放在0x0021地址中，当定义int* p，并且将&a赋值给p时，在内存中有另外一块地址（0x0087）存放着p的值，
也就是a的地址值0x0021，所以此处p的值为0x0021，p的地址为0x0087,
扩展：如果此处再定义一个指针变量，用来存放p的地址，则这个指针变量叫做二级指针变量，一级指针存放变量内存地址，二级指针存放指针内存地址
通过指针间接修改变量的值：
int a = 10;
int* p;
p = &a;
*p = 100; 取地址运算符 * 代表从p指向的地址中获取到值
printf("%d\n",a);
printf("%d\n",*p); 两个打印的结果一样
指针的大小
int a = 10;
int* p = &a;
printf("%d\n",sizeof(int*));
printf("%d\n",sizeof(p)); 两个打印结果是一样的
指针类型存储的都是内存地址，32位系统一个指针类型大小占4Byte，64位系统一个指针类型大小占8Byte
一个char类型的数据占内存是1Byte，但是指向他的指针占的内存是4Byte或者8Byte，这跟操作系统是多少位有关系
所以指针类型所占的大小跟是什么数据类型的指针没有关系，而跟系统是多少位的有关系
问题：既然指针变量都是无符号16进制整形数，都占4个字节大小，能不能这样写：
int a = 10;
int p = &a;
不用int*定义指针变量
答案：是可以这样写，而且也不会报错，但是这个时候p就是一个整形变量了，而不是一个指针变量，当用到取值符号取值的时候就该哭（报错）了
但是如果非要这么写也可以，需要这样：
*(int*)p = 100;
先将p强制转换成指针变量，这样p就成了一个指针变量了，再取值进行赋值操作就可以了
问题：既然指针变量都是无符号16进制整形数，都占4个字节大小，能不能这样写：
char ch = 97;
int* p = &ch;
printf("%p\n",&ch);
printf("%p\n",p);
答案：两者打印结果是一样的，都为变量ch的地址，这样写不会报错，但是当通过*p给ch重新赋值的时候就会出错，如下：
*p = 100; 给*p赋值为100
printf("%d\n",*p);
printf("%d\n",ch);
程序要么数据不对，要么会奔溃，这是因为int类型的指针p指向了char类型的变量，当用取值符*取值的时候，他会按照int类型的变量去读数据，读取4个
字节的数据，而我们的数据是char类型的，只占一个字节，所以数据会出错，进而导致奔溃。
所以在定义指针类型指向变量地址的时候，一定要和变量类型对应上
野指针
int* p = 100; int类型的指针变量p，指向内存编号为100的地址，词句并不会报错
printf("%d\n",*p); 打印p所指向地址的值，报错了，因为操作系统将0-255作为系统占用空间，不允许访问操作
以上代码中指针变量p就是一个野指针，野指针表示指针变量指向一个未知的空间，未知表示不是自己申请的空间。
操作野指针对应的内存空间可能会报错，也可能不报错
程序中允许出现野指针
不建议直接将一个变量的值直接赋值给指针
通常写代码，定义一个指针，之后经过一系列操作，这个指针指向了另外一片未知的空间，他就成为了野指针，所以一般情况下写代码，操作完指针之后都需要将其置位NULL
空指针
空指针是指内存地址编号为0的空间
int* p = NULL;
空指针对应的地址不允许读和写，因为0对应的地址也包含在0-255，操作空指针对应的空间一定会报错
空指针可以用于条件判断
万能指针void*
万能指针可以指向任意变量的内存空间
int a = 10;
void* p = &a; void*可以接收任意类型变量的内存空间
*p = 100; 这一行会报错，错误提示：非法的间接寻址，表达式必须是可修改的左值，这是为什么呢？
//打印两行内容看看
printf("%d\n",sizeof(void*)); 打印结果为4 正常，因为地址值都是unsigned int 占4位
printf("%d\n",sizeof(void)); 会报错，编译不通过，提示不允许使用不完整的类型，void是不完整的，
说明都没有办法获取sizeof(void)的大小，更别说去用取值符获取他的值了，连取几个字节的数据都不知道
想要通过万能指针修改变量的值时，需要找到变量对应的指针类型，也就是需要知道这个变量到底是什么数据类型的
*(int*)p = 100; 先把p强转成int类型的指针，然后再用取值符取值并且改变他的值。
万能指针一般用于作为函数的形参，并且同时形参还需要一个，告诉函数该万能指针指向的数据类型占多少个字节
万能指针可以赋值给任意一个指针变量：
int a = 10;
void* p1 = &a;
int* p2 = p1;
但是实际操作修改值的时候，还是要将原来的指针类型匹配上。
const修饰的指针类型
const常常用来修饰常量，其修饰的变量是不能直接被修改的，但是可以使用指针的方式来间接修改他的值
const int a = 10;
int* p = &a;
*p = 100;
printf("%d\n",a);打印结果为100
但是通过#define定义的常量是没办法修改的，这是因为const定义的常量是在栈区存储的，而#define定义的常量是存放在数据区的，
栈区的数据是可以修改的，数据区的数据是不能修改的
当然，const也可以修饰指针变量，有三种形式
1、const int* p = &a;
const修饰指针类型int*，可以修改指针变量的值，不可以修改指针指向内存空间的值*p
2、int* const p = &a;
const修饰指针变量p，可以修改指针指向内存空间的值*p，不可以修改指针变量的值p
3、const int* const p = &a;
const修饰指针类型int* 也修饰指针变量p，不可以修改指针变量的值，也不可以修改指针指向内存空间的值
但是之前说了，普通的常量，可以使用一级指针进行修改，同样的，一级指针常量，可以使用二级指针进行修改
int a = 10;
int b = 20;
const int* const p = &a;
int** pp = &p 定义一个二级指针pp，将指针p的地址赋值给二级指针变量pp
*pp = &b; 使用一个取值符*获取pp的值，也就是降维度成为一级指针，改变他的值为b的地址可以将*p的值改变为20
**pp = 100; 也可以直接使用两个取值符**，降维度成为变量，直接给变量赋值100 也可以
结论：通过二级指针可以修改一级指针的值，也可以修改一级指针指向内存空间的值，同样的道理，三级指针可以修改二级指针的值，也可以修改二级
指针指向内存空间的值。
指针和数组
数组名字是数组的首元素地址，但他是一个常量，所以数组名不能修改
int arr[] = {
1,2,3,4,5,6,7,8,9,10};
int* p = arr; 因为arr本身就是一个地址，所以这样赋值是没有问题的,而且两者的地址也是一样的
printf("%p\n",p);
printf("%p\n",arr);
for(int i = 0;i < 10;i++){
printf("%d\n",arr[i]);
}
可以看到，这里利用数组名arr和一个下标i就可以遍历整个数组的元素，那么p和arr一样，也是个地址，使用p和下标i是不是也能遍历所有的元素呢？
for(int i = 0;i<10;i++){
printf("%d\n",p[i]); 也可以打印出来整个数组的元素
}
既然arr和p都是地址，那么这样写来获取数组的第一个元素也是可以的：
printf("%d\n",*arr);
使用地址arr和角标i就可以遍历整个数组中的元素，arr是个常量不能改变，变得只是i，那么我们可以认为i是一个偏移量，那么这样打印一下
printf("%d\n",*(arr+4)); 发现打印的结果是5
那么：
printf("%d\n",*(arr+1)); 打印的结果为1
也就是说 *(arr+1) 和arr[1]结果是一样的
所以数组中数组名arr和角标i的组合也可以写成地址p加偏移量i再用*取值
那么这里有一个问题，这里int类型的数组一个元素占用的内存空间是4个字节，我为什么地址+4的时候，直接跑到了第5个元素上去，而地址+1的时候却在第二个元素上?
这是因为：
指针变量+1 等同于 内存地址+sizeof(数据类型)
打印+1的地址来证明
int arr[] = {
1,2,3,4,5,6,7,8,9,10};
int* p = arr;
p++;
printf("%p\n",arr);
printf("%p\n",p);
打印结果，p比arr多4
两个指针相减，得到的结果是两个指针的偏移量，步长，所有指针类型，相减的结果都是int类型
指针p和数组名arr的区别：p是变量，可以改变，arr是常量，不能改变
sizeof§和sizeof(arr)不同，p是一个指针，4个字节大小，arr是一个数组，40个字节大小（按照以上代码计算）
练习：写一个函数，参数是数组，打印数组的元素个数
void GetCount(int arr[]){
int len = sizeof(arr)/sizeof(arr[0]);
printf("len = %d\n",len);
}
调用该函数的时候，发现无论arr的元素个数是多少，最后打印的值都是1，
这是因为数组名本身既是一个数组名，也是一个指针，但当他作为函数的参数时，会退化为指针，丢失数组的精度
也就是说，一旦arr被传进这个函数中，无论arr里面元素个数是多少，sizeof(arr) = 4，sizeof(arr[0]) = 4 ，所以结果始终是1
所以一般情况下，数组名作为函数的参数时，同时会将数组元素个数也传进来，要不然进了函数里面没办法计算
学到这里，就应该明白例如冒泡排序的函数：
void BubbleSort(int arr[],int len){
for(int i = 0;i < len; i++){
for(int j = 0; j< len-1-i; j++){
if(arr[j] > arr[j+1]){
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
}
这里面执行的arr[j]或者arr{j+1}里面的arr其实都是指针，而不是一个数组名了，我们知道使用arr[j+1]这样的方式也可以获取指针的值
所以上面的代码也可以写成：
void BubbleSort(int arr[],int len){
for(int i = 0;i < len; i++){
for(int j = 0; j< len-1-i; j++){
if(arr[j] > arr[j+1]){
int temp = *(arr+j+1);
*(arr+j+1) = *(arr+j);
*(arr+j) = temp;
}
}
}
}
两份代码原理一样，但是一般不写这种，阅读性不强
指针加减运算
加法运算
指针相加不是简单的整数相加
如果是一个int*，+1的结果是增加一个int的大小
如果是一个char* +1的结果是增加一个char的大小
练习：字符串复制
void my_strcpy(char* dest, char* ch){
int i = 0;
while(ch[i] != '\0'){
这一行判断中也可以写成ch[i] != 0 还可以写成ch[i]
dest[i] = ch[i];
i++;
}
dest[i] = 0;
}
void main(){
char ch[] = "hello world";
char dest[100];
my_strcpy(dest, ch);
return 0;
}
方法二：指针操作，其实原理还是数组原理
void my_strcpy(char* dest,char* ch){
int i = 0;
while(*(ch+i)){
*(dest+i) = *(ch+i);
i++;
}
*(dest+i) = 0;
}
方法三：指针操作，真正意义上的指针操作
void my_strcpy(char* dest,char* ch){
while(*ch){
*dest = *ch;
dest++; 指针+1，相当于指向数组下一个元素，内存地址变化了sizeof(char)大小
ch++;
}
*dest = 0;
}
方法四：终极精简版本，原理和方法三一样，只不过更加简洁而已
void my_strcpy(char* dest,char* ch){
while(*dest++ = *ch++); 这一行代码，包含的操作有：*dest = *ch;
} dest++; ch++;
while(*dest!=0)
减法运算
例子：
int main(){
int arr[] = {
1,2,3,4,5,6,7,8,9,10};
int* p = &arr[3];
printf("%p\n",arr); 0x0028FF14
printf("%p\n",p); 0x0028FF20
return 0;
}
以上代码运行结果中，arr为数组的首元素的地址，p为下标为3的元素的地址，两者相差12，计算步长的话：
printf("step = %d\n",p - arr); step= 3 因为计算的是int类型指针的步长
如果这样改一下代码：
int main(){
int arr[] = {
1,2,3,4,5,6,7,8,9,10};
int* p = &arr[3];
p--;
p--;
p--;
printf("%p\n",arr); 0x0028FF14
printf("%p\n",p); 0x0028FF14
return 0;
}
打印的两个地址一样了，p–的执行过程就是指针向后退一格指针单位，具体指针单位是多少，和指针类型有关系
例如int类型的指针，自减运算之后指针向后偏移4字节，char类型的指针，自减运算之后指针向后偏移1字节
以上自减运算同样可以写为：指针变量 - 偏移量，例如在指针p指向下标为3的元素时，我想要获取下标为1的元素的值：
int main(){
int arr[] = {
1,2,3,4,5,6,7,8,9,10};
int* p = &arr[3];
printf("%d\n",*(p-2));
return 0;
}
运行结果为2
目前结论为，指针可以进行+运算和-运算，但是仅限于偏移量
注意：指针变量和指针变量进行加法，减法，乘除，取余都是无意义的
指针变量之间可以进行比较大小操作，等于和不等于
指针数组
定义：他是数组，数组中的每个元素都是指针类型
int main(){
int a = 10;
int b = 20;
int c = 30;
int* arr[3] = {
&a,&b,&c};
return 0;
}
遍历数组中的指针对应的值：
for(int i = 0;i < sizeof(arr)/sizeof(arr[0]);i++){
printf("%d\n",*arr[i]);
}
例子：定义3个int类型的一维数组a,b,c，每个数组3个元素，a b c也就是3个int类型的指针变量，组成一个指针数组arr
int a[] = {
1,2,3};
int b[] = {
4,5,6};
int c[] = {
7,8,9};
int* arr[3] = {
a,b,c};
要求遍历arr中每个指针对应的值？
for(int i = 0;i < 3; i++){
printf("%d\n",*(arr[i]));
}
打印结果为 1 4 7 分别为a[0],b[0],c[0]，那么思考怎么给指针加一个偏移量呢？
printf("%p\n",arr[0]); 指针a
printf("%p\n",a); 数组a
printf("%p\n",&a[0]); 数组a的首元素地址
打印这三个值，结果相等
既然arr[0]指针和a相等，那么我要获取到a[1]的值，是不是可以使用arr[0][1]？
for(int i = 0;i < 3; i++){
for(int j = 0;j < 3; j++){
printf("%d ",arr[i][j]);
}
puts("");
}
结果可以打印出所有的元素，可以看出来，该遍历方式是以二维数组的思路去解的，其实指针数组实际上就是一个二维数组的特殊模型
上面说到arr[0]指针和a相等，a也是一个指针，那么可以使用指针加偏移量的方式来获取全部的元素
for(int i = 0;i < 3; i++){
for(int j = 0;j < 3; j++){
printf("%d ",*(arr[i]+j));
}
puts("");
}
结果也可以打印出所有的元素，那么再思考，j可以当做偏移量，那么i应该也可以：
for(int i = 0;i < 3; i++){
for(int j = 0;j < 3; j++){
printf("%d ",*(*(arr+i)+j)); arr是指向数组a的指针，加i偏移量之后取值，得到指针a，继续加偏移量取值获取到a[0]的值
}
puts("");
}
可以看到使用到了二级指针，其实指针数组对应于二级指针
所以这个时候就不能写:
int* p = arr;
这样写虽然没有问题，但是指针层级会有问题，arr是一个二级指针，p是一个一级指针
多级指针
C语言允许有多级指针存在，在实际的程序中，一级指针最常用，其次是二级指针，
二级指针就是指向一个一级指针的指针
int a = 10;
int* p = &a;
int** pp = &p;
int*** ppp = &pp;
以上代码中，存在如下关系
*ppp == pp == &p
(二级指针) （二级指针） （二级指针）
**ppp == *pp == p == &a
(一级指针)
***ppp == **pp == *p == a
(值)