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];
这两种赋值方法是等价的.
