指针
1.关于内存那点事
存储器：存储数据器件
外存
外存又叫外部存储器，长期存放数据，掉电不丢失数据
常见的外存设备：硬盘、 flash 、 rom 、 u 盘、光盘、磁带
内存
内存又叫内部存储器，暂时存放数据，掉电数据丢失
常见的内存设备： ram 、 DDR
物理内存：实实在在存在的存储设备
虚拟内存：操作系统虚拟出来的内存。
操作系统会在物理内存和虚拟内存之间做映射。
在 32 位系统下，每个进程（运行着的程序）的寻址范围是 4G,0x00 00 00 00 ~0xff ff ff ff
在写应用程序的，咱们看到的都是虚拟地址。
在运行程序的时候，操作系统会将 虚拟内存进行分区。
1.堆
在动态申请内存的时候，在堆里开辟内存。
2.栈
主要存放局部变量（在函数内部，或复合语句内部定义的变量）。
3.静态全局区
1 ）：未初始化的静态全局区
静态变量（定义的时候，前面加 static 修饰），或全局变量 ，没有初始化的，存在此区
2 ）：初始化的静态全局区
全局变量、静态变量，赋过初值的，存放在此区
4.代码区
存放咱们的程序代码
5.文字常量区
存放常量的。
内存以字节为单位来存储数据的，咱们可以将程序中的虚拟寻址空间，看成一个很大的一维的字符数组
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 个地址编号。
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 68
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.指针大小
在 32 位系统下，
所有类型的指针都是 4 个字节
例 3：在 32 位系统下，
所有类型的指针都是 4 个字节
#include
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
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;
}
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.指针和变量的关系
指针可以存放变量的地址编号
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
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
int main()
{
int a=0x12345678,b=0xabcdef66;
char *p1,*p2;
printf("%0x %0x\n",a,b);
p1=(char *)&a;
p2=(char *)&b;
p1++;
p2++;
printf("%0x %0x\n",*p1,*p2);
return 0;
}
结果为：
0x 78 0x66
0x56 0xef
注意：
1 ： *+ 指针 取值，取几个字节，由指针类型决定的指针为字符指针则取一个字节，
指针为整型指针则取 4 个字节，指针为 double 型指针则取 8 个字节。
2 ：指针 ++ 指向下个对应类型的数据
字符指针 ++ ，指向下个字符数据，指针存放的地址编号加 1
整型指针 ++, 指向下个整型数据，指针存放的地址编号加 4
6.指针和数组元素之间的关系
变量存放在内存中，有地址编号，咱们定义的数组，是多个相同类型的变量的集合，
每个变量都占内存空间，都有地址编号
指针变量当然可以存放数组元素的地址。
例 7：
int a[5];
//int *p =&a[0];
int *p;
p=&a[0];// 指针变量 p 保存了数组 a 中第 0 个元素的地址，即 a[0]的地址
数组元素的引用方法
方法 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
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;
}
指针的运算
1 ：指针可以加一个整数 , 往下指几个它指向的变量，结果还是个地址
前提：指针指向数组元素的时候，加一个整数才有意义
例 9：
int a[5];
int *p;
p=a;
p+2;//p 是 a[0]的地址，p+2 是&a[2]
假如 p 保存的地址编号是 2000 的话， p+2 代表的地址编号是 2008
例 10：
char buf[5]；
char *q;
q=buf;
q+2 //相当于&buf [2]
假如： q 中存放的地址编号是 2000 的话， q+2 代表的地址编号是 2002
2 ：两个相同类型指针可以比较大小
前提： 只有两个 相同类型的指针 指向 同一个数组的元素 的时候，比较大小才有意义
指向前面元素的指针 小于 指向后面 元素的指针
例 11：
#include
int main(int argc, char *argv[])
{
int a[10];
int *p,*q,n;//如果在一行上定义多个指针变量的，每个变量名前面加*
//上边一行定义了两个指针 p 和 q ，定义了一个整型的变量 n
p=&a[1];
q=&a[6];
if(p
{
printf("p
}
else if(p>q)
{
printf("p>q\n");
}
else
{
printf("p == q\n");
}
return 0;
}
结果是 p
3. 两个相同类型的指针可以做减法
前提： 必须是 两个相同类型的指针 指向 同一个数组的元素 的时候，做减法才有意义
做减法的结果是，两个指针指向的中间有多少个元素
例 12:
#include
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]; 这两种赋值方法是等价的
7.指针数组
1、指针和数组的关系
1 ：指针可以保存数组元素的地址
2 ：可以定义一个数组，数组中有 若干个相同类型指针变量 ，这个数组被称为指针数组 int *p[5]
指针数组的概念：
指针数组本身是个数组，是个指针数组 ，是若干个相同类型的指针变量构成的集合
2、指针数组的定义方法：
类型说明符 * 数组名 [ 元素个数 ];
int * p[5];// 定义了一个整型的指针数组 p ，有 5 个元素 p[0]~p[4],
每个元素都是 int * 类型的变量
int a;
p[0]=&a;
int b[10];
p[1]=&b[5];
p[2] 、 *(p+2) 是等价的，都是指针数组中的第 2 个元素。
例 13：
#include
int main(int argc, char *argv[])
{
char *name[5] = {"hello","China","beijing","project","Computer"};
int i;
for(i=0;i<5;i++)
{
printf("%s\n",name[i]);
}
return 0;
}
“hello” 、“ China ”“
beijing ” “
project ” “
computer ” 这 5 个字符串存放在文字常量区。
假设：
“ hello ”首地址是 0x00002000
“ China ”首地址是 0x00003000
“
beijing ”首地址是 0x00004000
“
project ”首地址是 0x00005000
“ Computer ”首地址是 0x00006000
则：
name[0] 中存放内容为 0x00002000
name[1] 中存放内容为 0x00003000
name[2] 中存放内容为 0x00004000
name[3] 中存放内容为 0x00005000
name[4] 中存放内容为 0x00006000
3、指针数组的分类
字符指针数组 char *p[10] 、短整型指针数组、整型的指针数组、长整型的指针数组
float 型的指针数组、 double 型的指针数组
结构体指针数组、函数指针数组
8.指针的指针
指针的指针，即指针的地址，
咱们定义一个指针变量本身指针变量占 4 个字节，指针变量也有地址编号。
例：
int a=0x12345678 ；
假如： a 的地址是 0x00002000
int *p;
p =&a;
则 p 中存放的是 a 的地址编号即 0x00002000
因为 p 也占 4 个自己内存，也有它自己的地址编号，及指针变量的地址，即指针的指针。
假如：指针变量 p 的地址编号是 0x00003000 ，这个地址编号就是指针的地址
我们定义一个变量存放 p 的地址编号，这个变量就是指针的指针
int **q;
q=&p;//q 保存了 p 的地址，也可以说 q 指向了 p
则 q 里存放的就是 0x00003000
int ***m;
m=&q;
p q m 都是指针变量，都占 4 个字节，都存放地址编号，只不过类型不一样而已
9.字符串和指针
字符串的概念：
字符串就是以 ’\0’ 结尾的若干的字符的集合：比如“
helloworld ”。
字符串的地址，是第一个字符的地址。如：字符串“
helloworld ”的地址，其实是字符串中字符 ’h’ 的地址。
我们可以定义一个字符指针变量保存字符串的地址 , 比如： char *s =”helloworld”;
字符串的存储形式： 数组、文字常量区、堆
1、 字符串存放在数组中
其实就是在内存（栈、静态全局区）中开辟了一段空间存放字符串。
char string[100] = “I love C!”
定义了一个字符数组 string, 用来存放多个字符，并且用 ”I love C!” 给 string 数组初始化 ，
字符串“I love C！”存放在 string 中。
注： 普通全局数组，内存分配在静态全局区
普通局部数组，内存分配在栈区。
静态数组（静态全局数组、静态局部数组），内存分配在静态全局区
2、 字符串存放在文字常量区
在文字常量区开辟了一段空间存放字符串，将字符串的 首地址 付给指针变量。
char *str = “I love C!”
定义了一个指针变量 str, 只能存放字符地址编号，
I love C ！ 这个字符串中的字符不是存放在 str 指针变量中。
str 只是存放了字符 I 的地址编号，“
I love C ！”存放在文字常量区
3、 字符串存放在堆区
使用 malloc 等函数在堆区申请空间，将字符串拷贝到堆区。
char *str =(char*)malloc(10);// 动态申请了 10 个字节的存储空间，
首地址给 str 赋值。
strcpy(str,"I love C") ； // 将字符串“Ｉ
love C! ”拷贝到 str 指向的内存里
字符串的可修改性：
字符串内容是否可以修改，取决于字符串存放在哪里
1. 存放在数组中的字符串的内容是可修改的
char str[100]=”I love C!”;
str[0]= ‘y’ ;// 正确可以修改的
注：数组没有用 const 修饰
2. 文字常量区里的内容是不可修改的
char *str=”I love C!”;
*str =’y’;// 错误， I 存放在文字常量区，不可修改
注：
1 、 str 指向文字常量区的时候，它指向的内存的内容不可被修改。
2 、 str 是指针变量可以指向别的地方，即可以给 str 重新赋值，让它指向别的地方。
3. 堆区的内容是可以修改的
char *str =(char*)malloc(10);
strcpy(str,"I love C");
*str=’y’;// 正确，可以，因为堆区内容是可修改的
注：
1 、 str 指向堆区的时候， str 指向的内存内容是可以被修改的。
2 、 str 是指针变量，也可以指向别的地方。即可以给 str 重新赋值，让它指向别的地方
注意： str 指针指向的内存能不能被修改，要看 str 指向哪里。
str 指向文字常量区的时候，内存里的内容不可修改
str 指向数组（非 const 修饰）、堆区的时候，它指向内存的内容是可以修改
初始化：
1. 字符数组初始化：
char buf_aver[20]="hello world";
2. 指针指向文字常量区，初始化：
char *buf_point="hello world";
3 、指针指向堆区，堆区存放字符串。
不能初始化，只能先给指针赋值，让指针指向堆区，再使用 strcpy 、 scanf 等方法把字符串拷贝到堆区。
char *buf_heap;
buf_heap=(char *)malloc(15);
strcpy(buf_heap,"hello world");
scanf(“%s”,buf_heap);
使用时赋值
1. 字符数组：使用 scanf 或者 strcpy
char buf[20]=”hello world”
buf="hello kitty";
错误 , 因为字符数组的名字是个常量 , 不能用等号给常量赋值。
strcpy(buf,"hello kitty"); 正确，数组中的内容是可以修改的
scanf("%s",buf);
正确，数组中的内容是可以修改的
2. 指针指向文字常量区
char *buf_point = “hello world”;
1) buf_point="hello kitty";
正确 ,buf_point 指向另一个字符串
2) strcpy(buf_point,"hello kitty"); 错误，这种情况， buf_point 指向的是文字常量区，内容只读。
当指针指向文字常量区的时候，不能通过指针修改文字常量区的内容。
3. 指针指向堆区，堆区存放字符串
char *buf_heap;
buf_heap=(char *)malloc(15);
strcpy(buf_heap,"hello world");
scanf(“%s”,buf_heap);
字符串和指针总结：
1 、指针可以指向文字常量区
1 ）指针指向的文字常量区的内容不可以修改
2 ）指针的指向可以改变，即可以给指针变量重新赋值，指针变量指向别的地方。
2 、指针可以指向堆区
1 ）指针指向的堆区的内容可以修改。
2 ）指针的指向可以改变，即可以给指针变量重新赋值，指针变量指向别的地方。
3 、指针也可以指向数组（非 const 修饰）
例：
char buf[20]="hello world";
char *str=buf;
这种情况下
1. 可以修改 buf 数组的内容。
2. 可以通过 str 修改 str 指向的内存的内容，即数组 buf 的内容
3. 不能给 buf 赋值 buf= “ hello kitty ”；错误的。
4. 可以给 str 赋值，及 str 指向别处。 str= “
hello kitty ”
