5.1.1 关于内存那点事
存储器：存储数据器件
外存
外存又叫外部存储器，长期存放数据，掉电不丢失数据
常见的外存设备：硬盘、flash、rom、u 盘、光盘、磁带
内存
内存又叫内部存储器，暂时存放数据，掉电数据丢失
常见的内存设备：ram、DDR
物理内存：实实在在存在的存储设备
虚拟内存：操作系统虚拟出来的内存。
操作系统会在物理内存和虚拟内存
编辑
编辑
在 32 位系统下，每个进程（运行着的程序）的寻址范围是 4G,0x00 00 00 00 ~0xff ff ff ff
在写应用程序的，咱们看到的都是虚拟地址。
在运行程序的时候，操作系统会将 虚拟内存进行分区。
1.堆 在动态申请内存的时候，在堆里开辟内存。
2.栈 主要存放局部变量（在函数内部，或复合语句内部定义的变量）。
3.静态全局区
(1）：未初始化的静态全局区静态变量（定义的时候，前面加 static 修饰），或全局变量 ，没有初始化的，存在此区
(2）：初始化的静态全局区 全局变量、静态变量，赋过初值的，存放在此区
4.代码区 存放咱们的程序代码
5.文字常量区 存放常量的。 内存以字节为单位来存储数据的，咱们可以将程序中的虚拟寻址空间，看成一个很大的一维的字符数组.
5.1.2 指针的概念
系统给虚拟内存的每个存储单元分配了一个编号，从 0x00 00 00 00 ~0xff ff ff ff 这个编号咱们称之为地址
指针就是地址
编辑
指针变量：是个变量，是个指针变量，即这个变量用来存放一个地址编号
在 32 位平台下，地址总线是 32 位的，所以地址是 32 位编号，所以指针变量是 32 位的即 4 个字节。
注意：1： 无论什么类型的地址，都是存储单元的编号，在 32 位平台下都是 4 个字节， 即任何类型的指针变量都是 4 个字节大小
2：对应类型的指针变量，只能存放对应类型的变量的地址
举例：整型的指针变量，只能存放整型变量的地址.
扩展： 字符变量 char ch=‘b’; ch 占 1 个字节，它有一个地址编号，这个地址编号就是 ch 的地址 整型变量 int a=0x12 34 56 78; a 占 4 个字节，它占有 4 个字节的存储单元，有 4 个地址编号.
编辑
5.1.3 指针变量的定义方法
1.简单的指针变量 数据类型 * 指针变量名;
int * p;//定义了一个指针变量 p 在 定义指针变量的时候 * 是用来修饰变量的，说明变量 p 是个指针变量。 变量名是 p
2.关于指针的运算符 & 取地址 、 *取值
例 1：
int a=0x1234abcd;
int *p;//在定义指针变量的时候*代表修饰的意思，修饰 p 是个指针变量。
p=&a;//把 a 的地址给 p 赋值 ，&是取地址符
p 保存了 a 的地址，也可以说 p 指向了 a
p 和 a 的关系分析：a 的值是 0x1234abcd，假如 a 的地址是：0xbf e8 98 6
编辑
int num；
num=*p
分析：
1、在调用的时候 代表取值得意思 ，p 就相当于 p 指向的变量，即 a，
2、故 num=*p 和 num =a 的效果是一样的。 *
3、所以说 num 的值为 0x1234abcd。
扩展：如果在一行中定义多个指针变量，每个指针变量前面都需要加来修饰
int * p,*q; //定义了两个整型的指针变量 p 和 q
int * p, q; //定义了一个整型指针变量 p，和整型的变量 q
例 2：
int main()
{
int a= 100, b = 200;
int *p_1, *p_2 = &b; //表示该变量的类型是一个指针变量，指针变量名是 p_1 而不是*p_1.
//p_1 在定义的时候没有赋初值，p_2 赋了初值
p_1＝&a； //p_1 先定义后赋值
printf("%d\n", a);
printf("%d\n", *p_1)
printf("%d\n", b);
printf("%d\n", *p_2);
return 0;
}
注意： 在定义 p_1 的时候，因为是个局部变量，局部变量没有赋初值，它的值是随机的，p_1 指向哪里不一定， 所以 p_1 就是个野指针。
3.指针大小
例 3：在 32 位系统下，所有类型的指针都是 4 个字节
#include <stdio.h>
int main(int argc, char *argv[])
{
char *p1;
short int *p2;
int *p3;
long int *p4;
float *p5;
double *p6;
printf("%d\n",sizeof(p1));
printf("%d\n",sizeof(p2));
printf("%d\n",sizeof(p3));
printf("%d\n",sizeof(p4));
printf("%d\n",sizeof(p5));
printf("%d\n",sizeof(p6));
return 0;
}
例 4：
#include <stdio.h>
int main(int argc, char *argv[])
{
int a=0x1234abcd;
int *p;
p=&a;
printf("&a=%p\n",&a);
printf("p=%p\n",p)
return 0;
}
编辑
5.1.4 指针的分类
按指针指向的数据的类型来分
1:字符指针 字符型数据的地址 char *p;//定义了一个字符指针变量，只能存放字符型数据的地址编号
char ch;
p= &ch;
2：短整型指针 short int *p;//定义了一个短整型的指针变量 p，只能存放短整型变量的地址
short int a;
p =&a;
3：整型指针
int *p;//定义了一个整型的指针变量 p，只能存放整型变量的地址
int a;
p =&a;
注：多字节变量，占多个存储单元，每个存储单元都有地址编号，
c 语言规定，存储单元编号最小的那个编号，是多字节变量的地址编号。
4：长整型指针
long int *p;//定义了一个长整型的指针变量 p，只能存放长整型变量的地址
long int a;
p =&a;
5：float 型的指针
float *p;//定义了一个 float 型的指针变量 p，只能存放 float 型变量的地址
float a;
p =&a;
6：double 型的指针
double *p;//定义了一个 double 型的指针变量 p，只能存放 double 型变量的地址
double a;
p =&a;
7：函数指针
8、结构体指针
9、指针的指针
10、数组指针
11、通用指针 void *p;
总结:无论什么类型的指针变量，在 32 位系统下，都是 4 个字节。
指针只能存放对应类型的变量的地址编号。
5.1.5 指针和变量的关系
指针可以存放变量的地址编号
int a=100;
int *p;
p=&a;
在程序中，引用变量的方法
1:直接通过变量的名称 int a; a=100;
2:可以通过指针变量来引用变量
int * p;//在定义的时候，*不是取值的意思，而是修饰的意思，修饰 p 是个指针变量
p=&a;//取 a 的地址给 p 赋值，p 保存了 a 的地址，也可以说 p 指向了 a
* p= 100;//在调用的时候是取值的意思， * 指针变量 等价于指针指向的变量
注：指针变量在定义的时候可以初始化 int a;
int *p=&a;//用 a 的地址，给 p 赋值，因为 p 是指针变量
指针就是用来存放变量的地址的。
*+指针变量 就相当于指针指向的变量
例 5：
#include <stdio.h>
int main()
{
int *p1,*p2,temp,a,b;
p1=&a;
p2=&b;
printf("请输入:a b 的值:\n");
scanf_s("%d %d",p1,p2);//给 p1 和 p2 指向的变量赋值
temp = *p1; //用 p1 指向的变量（a）给 temp 赋值
*p1 = *p2; //用 p2 指向的变量（b）给 p1 指向的变量（a）赋值
*p2 = temp;//temp 给 p2 指向的变量（b）赋值
printf("a=%d b=%d\n",a,b);
printf("*p1=%d *p2=%d\n",*p1,*p2);
return 0;
}
运行结果：
输入 100 200
输出结果为： a=200 b=100
*p1=200 *p2=100
扩展： 对应类型的指针，只能保存对应类型数据的地址， 如果想让不同类型的指针相互赋值的时候，需要强制类型转换 void * p
例 6：
#include <stdio.h>
int main()
{
int a=0x12345678,b=0xabcdef66;
char *p1,*p2;
printf("%0x %0x\n",a,b);
p1=(char *)&a;
p2=(char *)&b;
printf("%0x %0x\n",*p1,*p2);
p1++;
p2++;
printf("%0x %0x\n",*p1,*p2);
return 0;
}
编辑
结果为：
0x 78 0x66
0x56 0xef
注意：
1：*+指针 取值，取几个字节，由指针类型决定的指针为字符指针则取一个字节， 指针为整型指针则取 4 个字节，指针为 double 型指针则取 8 个字节。
2：指针++ 指向下个对应类型的数据 字符指针++ ，指向下个字符数据，指针存放的地址编号加 1 整型指针++,指向下个整型数据，指针存放的地址编号加 4
5.1.6 指针和数组元素之间的关系
1、 变量存放在内存中，有地址编号，咱们定义的数组，是多个相同类型的变量的集合， 每个变量都占内存空间，都有地址编号 指针变量当然可以存放数组元素的地址。
例 7：
int a[5];
//int *p =&a[0];
int *p;
p=&a[0];//
指针变量 p 保存了数组 a 中第 0 个元素的地址，即 a[0]的地
编辑
2、数组元素的引用方法
方法 1: 数组名[下标] int a[5]; a[2]=100;
方法 2：指针名加下标 int a[5]; int *p; p=a; p[2]=100;//相当于 a[2]=100;
补充：c 语言规定：数组的名字就是数组的首地址，即第 0 个元素的地址，就是&a[0]，是个常量。
注意：p 和 a 的不同，p 是指针变量，而 a 是个常量。所以可以用等号给 p 赋值，但不能给 a 赋值。 p=&a[3];//正确
a=&a[3];//错误
方法 3：通过指针变量运算加取值的方法来引用数组的元素
int a[5];
int *p;
p=a;
*(p+2)=100;//也是可以的，相当于 a[2]=100
解释：p 是第 0 个元素的地址，p+2 是 a[2]这个元素的地址。 对第二个元素的地址取值，即 a[2]
方法 4：通过数组名+取值的方法引用数组的元素
int a[5];
*(a+2)=100;//也是可以的，相当于 a[2]=100; 注意：a+2 是 a[2]的地址。这个地方并没有给 a 赋值。
例 8：
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[5]={0,1,2,3,4};
int *p;
p=a;
printf("a[2]=%d\n",a[2]);
printf("p[2]=%d\n",p[2]);
printf("*(p+2)%d\n",*(p+2));
printf("*(a+2)%d\n",*(a+2));
printf("p=%p\n",p);
printf("p+2=%p\n",p+2);
return 0;
}
3、指针的运算
1：指针可以加一个整数,往下指几个它指向的变量，结果还是个地址 前提：指针指向数组元素的时候，加一个整数才有意义
例 9：
int a[5];
int *p;
p=a;
p+2;//p 是 a[0]的地址，p+2 是&a[2]
假如 p 保存的地址编号是 2000 的话，p+2 代表的地址编号是 2
例 10：
char buf[5]；
char *q;
q=buf;
q+2
假如：q 中存放的地址编号是 2000 的话，q+2 代表的地址编号是 2002
2：两个相同类型指针可以比较大小
前提：只有两个相同类型的指针指向同一个数组的元素的时候，比较大小才有意义 指向前面元素的指针 小于 指向后面 元素的指针
例 11：
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[10];
int *p,*q,n;//如果在一行上定义多个指针变量的，每个变量名前面加*
//上边一行定义了两个指针 p 和 q ，定义了一个整型的变量 n
p=&a[1];
q=&a[6];
if(p<q)
{
printf("p<q\n");
}
else if(p>q)
{
printf("p>q\n");
}
else
{
printf("p == q\n");
}
return 0;
}
结果是 p<q
3.两个相同类型的指针可以做减法
前提：必须是两个相同类型的指针指向同一个数组的元素的时候，做减法才有意义 做减法的结果是，两个指针指向的中间有多少个元素
例 12
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[5];
int *p,*q;
p=&a[0];
q=&a[3];
printf("%d\n",q-p);
return 0;
}
结果是 3
4：两个相同类型的指针可以相互赋值
注意:只有相同类型的指针才可以相互赋值（void *类型的除外）
int *p;
int *q;
int a;
p=&a;//p 保存 a 的地址，p 指向了变量 a
q=p; //用 p 给 q 赋值，q 也保存了 a 的地址，指向 a
注意：如果类型不相同的指针要想相互赋值，必须进行强制类型转换
注意：c 语言规定数组的名字，就是数组的首地址，就是数组第 0 个元素的地址，是个常量
int *p;
int a[5];
p=a;
p=&a[0];
这两种赋值方法是等价的.