青岛制作企业网站的公司,硬件定制,seo优化顾问服务,2024年个体工商户年报怎么填四、指针的分类
按指针指向的数据的类型来分
1:字符指针
字符型数据的地址
char *p;//定义了一个字符指针变量#xff0c;只能存放字符型数据的地址编号
char ch;
p ch;
2#xff1a;短整型指针
short int *p;//定义了一个短整型的指针变量p#xff0c…四、指针的分类
按指针指向的数据的类型来分
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;
5float 型的指针
float *p;//定义了一个float型的指针变量p只能存放float型变量的地址
float a;
p a;
6double型的指针
double *p;//定义了一个double型的指针变量p只能存放double型变量的地址
double a;
p a;
7函数指针
8、结构体指针
9、指针的指针
10、数组指针
总结:无论什么类型的指针变量在32位系统下都是4个字节只能存放对应类型的变量的地址编号。
五、指针和变量的关系
指针可以存放变量的地址编号
在程序中引用变量的方法
1:直接通过变量的名称
int a;
a100;
2:可以通过指针变量来引用变量
int *p;//在定义的时候*不是取值的意思而是修饰的意思修饰p是个指针变量
pa;//取a的地址给p赋值p保存了a的地址也可以说p指向了a
*p 100;//在调用的时候*是取值的意思*指针变量 等价于指针指向的变量
注指针变量在定义的时候可以初始化
int a;
int *pa;//用a的地址给p赋值因为p是指针变量
指针就是用来存放变量的地址的。
*指针变量 就相当于指针指向的变量
指针变量只能保存开辟好空间的地址不能随意保存地址
1 #include stdio.h
2
3 int main(int argc, char *argv[])
4 {
5 int *p1,*p2,temp,a,b;
6 p1a;7 p2b;
8
9 printf(请输入:a b的值:\n);
10 scanf(%d %d, p1, p2);//给p1和p2指向的变量赋值
11
12 temp *p1; //用p1指向的变量a给temp赋值
13 *p1 *p2; //用p2指向的变量b给p1指向的变量a赋值
14 *p2 temp;//temp给p2指向的变量b赋值
15
16 printf(a%d b%d\n,a,b);
17 printf(*p1%d *p2%d\n,*p1,*p2);
18
19 return 0;
20 } 扩展
对应类型的指针只能保存对应类型数据的地址
如果想让不同类型的指针相互赋值的时候需要强制类型转换
1 #include stdio.h
2
3 int main(int argc, char *argv[])
4 {
5 int a0x1234,b0x5678;
6 char *p1,*p2;
7 printf(%#x %#x\n,a,b);
8 p1(char *)a;
9 p2(char *)b;
10 printf(%#x %#x\n,*p1,*p2);
11 p1;
12 p2;
13 printf(%#x %#x\n,*p1,*p2);
14
15 return 0;
16 } 注意
1*指针 取值取几个字节由指针类型决定的指针为字符指针则取一个字节
指针为整型指针则取4个字节指针为double型指针则取8个字节。
2指针 指向下个对应类型的数据
字符指针 指向下个字符数据指针存放的地址编号加1
整型指针,指向下个整型数据指针存放的地址编号加4
6.1 数组元素与指针的基本关系
变量存放在内存中有地址编号咱们定义的数组是多个相同类型的变量的集合每个变量都占内存空间都有地址编号。指针变量当然可以存放数组元素的地址。
1 int a[10];
2 //int *p a[0];
3 int *p;
4 pa[0]; //指针变量p保存了数组a中第0个元素的地址即a[0]的地址
6.2 数组元素的引用方法
方法1: 数组名[下标]
int a[10];
a[2]100;
方法2指针名加下标
int a[10];
int *p;
pa;
p[2]100;//因为p和a等价
补充c语言规定数组的名字就是数组的首地址即第0个元素的地址是个常量。
注意p和a的不同p是指针变量而a是个常量。所以可以用等号给p赋值但不能给a赋值。
例如int a[10]; a就是错误的因为a是数组名是一个地址常量
方法3通过指针运算加取值的方法来引用数组的元素
int a[10];
int *p;
pa;
*(p2)100;//也是可以的相当于a[2]100
解释p是第0个元素的地址p2是 a[2]这个元素的地址。
对第二个元素的地址取值即a[2]
1 #include stdio.h
2
3 int main(int argc, char *argv[])
4 {
5 int a[5]{0,1,2,3,4};
6 int *p;
7 pa;
8
9 //只要将数组名赋值给同类型的指针变量则此时的指针变量与数组名可
10 //以用相同的方法操作数组
11 printf(a[2]%d\n,a[2]);
12 printf(p[2]%d\n,p[2]);
13
14 //*(a n) *(p n) a[n] p[n]
15 printf(*(p2) %d\n,*(p2));
16 printf(*(a2) %d\n,*(a2));
17
18 printf(p%p\n,p);
19 printf(p2%p\n,p2);
20 printf(a[0] %p\n, a[0]);
21 printf(a[2] %p\n, a[2]);
22 return 0;
23 } 七、指针的运算
7.1 指针可以加一个整数
往下指几个它指向的变量结果还是个地址
前提指针指向数组的时候加一个整数才有意义
1 //指针可以加一个整数,往下指几个它指向的变量结果还是个地址
2 void test1()
3 {
4 int a[10];
5 int *p, *q;
6 //p和q间隔8个字节意味着加一个整数最终移动的字节数与指针变量的类型也有关系
7 p a;
8 q p 2;
9
10 printf(p %p\n, p);
11 printf(q %p\n, q);
12
13 return ;
14 } 7.2 两个相同类型指针可以比较大小
前提只有两个相同类型的指针指向同一个数组的元素的时候比较大小才有意义
指向前面元素的指针 小于 指向后面 元素的指针
1 void test2()
2 {
3 int a[10];
4 int *p,*q;
5 pa[1];
6 qa[6];
7 if(pq)
8 {
9 printf(p q\n);
10 }
11 else if(pq)
12 {
13 printf(p q\n);
14 }
15 else
16 {
17 printf(p q\n);
18 }
19 } 7.3 两个相同类型的指针可以做减法
前提必须是两个相同类型的指针指向同一个数组的元素的时候做减法才有意义
做减法的结果是两个指针指向的中间有多少个元素
1 void test3()
2 {
3 int a[10];
4 int *p,*q;
5 pa[0];
6 qa[3];
7 printf(%d\n,q‐p);
8 } 7.4 两个相同类型的指针可以相互赋值
注意:只有相同类型的指针才可以相互赋值void *类型的除外
1 void test4()
2 {
3 int a 100;
4 int *p, *q;
5 p a;
6
7 printf(a %d %d\n, a, *p);
8
9 q p;
10 printf(*q %d\n, *q);
11
12 *q 999;
13 printf(a %d\n, a);
14 } 八、指针数组
1、指针和数组的关系
1指针可以保存数组元素的地址
2可以定义一个数组数组中有若干个相同类型指针变量这个数组被称为指针数组
指针数组的概念
指针数组本身是个数组是个指针数组是若干个相同类型的指针变量构成的集合
注意一般遇到这样的叠词本质就是后者
2、指针数组的定义方法
类型说明符 * 数组名 [元素个数];
1 int * p[10];//定义了一个整型的指针数组p有10个元素p[0]~p[9],每个元素都是int
*类型的变量
2 int a;
3 p[1]a;
4 int b[10];
5 p[2]b[3];
6 p[2]、*(p2)是等价的都是指针数组中的第2个元素。 3、指针数组的分类
字符指针数组char *p[10]、短整型指针数组、整型的指针数组、长整型的指针数组
float型的指针数组、double型的指针数组
结构体指针数组、函数指针数组
1 #include stdio.h
2
3 int main(int argc, char *argv[])
4 {
5 //大多数情况下指针数组都用来保存多个字符串
6 char *name[5] {Follw me,BASIC,Greatwall,FORTRAN,Computer};
7 int i;
8 for(i0;i5;i)
9 {
10 printf(%s\n,name[i]);
11 }
12
13 return 0;
14 }
15 九、指针的指针 -- 二级指针
指针的指针即指针的地址咱们定义一个指针变量本身指针变量占4个字节指针变量也有地址编号。 int a;
int *p;
pa;
*p a
int **q;
qp;
*q p
**q *p a
int ***m;
mq;
*(*(*m)) a
注意
p q m都是指针变量都占4个字节都存放地址编号只不过类型不一样而已
1 #include stdio.h
2
3 int main(int argc, char *argv[])
4 {
5 int a 100;
6
7 //定义一个一级指针
8 //一级指针用于保存普通变量的地址
9 int *p a;
10
11 //定义一个二级指针12 //二级指针用于保存一级指针的地址
13 int **q p;
14
15 printf(a %d %d %d\n, a, *p, **q);
16 printf(a %p %p %p\n, a, p, *q);
17 printf(p %p %p\n, p, q);
18 printf(q %p\n, q);
19
20 return 0; 十、字符串和指针
字符串的概念
字符串就是以’\0’结尾的若干的字符的集合
字符串的存储形式 数组、字符串指针、堆
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、 char *str (char*)malloc(10*sizeof(char));
动态申请了10个字节的存储空间首地址给str赋值。
strcpy(str,I love C)//将字符串“love C!”拷贝到str指向的内存里
总结
字符数组
在内存栈、静态全局区中开辟了一段空间存放字符串
字符串指针
在文字常量区开辟了一段空间存放字符串将字符串的首地址付给str
堆
使用malloc函数在堆区申请空间将字符串拷贝到堆区
注意
可修改性
1. 栈和全局区内存中的内容是可修改的
char str[100]”I love C!”;
str[0]‘y’;//正确可以修改的
2. 文字常量区里的内容是不可修改的
char *str”I love C!”;
*str ’y’;//错误I存放在文字常量区不可修改
3. 堆区的内容是可以修改的
char *str (char*)malloc(10*sizeof(char));
strcpy(str,I love C);
*str’y’;//正确可以因为堆区内容是可修改的
注意str指针指向的内存能不能被修改要看str指向哪里。
str指向文字常量区的时候内存里的内容不可修改
str指向栈、堆、静态全局区的时候内存的内容是可以修改
初始化
字符数组、指针指向的字符串定义时直接初始化
char buf_aver[]hello world;
char *buf_pointhello world;
堆中存放的字符串不能初始化、只能使用strcpy、scanf赋值
char *buf_heap;
buf_heap(char *)malloc(15);
strcpy(buf_heap,hello world);
scanf(“%s”,buf_heap);
使用时赋值
字符数组使用scanf或者strcpy
char buf_aver[128];
buf_averhello kitty; 错误,因为字符数组的名字是个常量
strcpy(buf_aver,hello kitty); 正确
scanf(%s,buf_aver); 正确
指向字符串的指针
char *buf_point;
buf_pointhello kitty; 正确,buf_point指向另一个字符串
strcpy(buf_point,hello kitty); 错误只读,能不能复制字符串到buf_piont指向
的内存里
取决于buf_point指向哪里。
