引言:
对指针知识进行简单的回顾,然后再完成笔试题。
✨ 猪巴戒:个人主页✨
所属专栏:《C语言进阶》
🎈跟着猪巴戒,一起学习C语言🎈
目录
知识简单回顾
指针是什么
内存 ->内存的单元(1byte)->编号->地址
我们有一块很大的内存空间,内存空间被分为一个一个的单元,一个内存单元的大小是1byte(字节),每个字节都有它的编号,这个编号就是地址,地址又叫做指针。
指针就是一个地址。
我们口头语说的指针一般指:指针变量
指针变量就是一个变量,就是一块内存空间,指针变量用来存放地址。
&a就是内存的编号,也是地址.
这个指针变量叫做pa,int*是类型(整形指针),通过这个类型创造的变量叫做pa。*pa就是对pa进行解引用,通过pa存放的地址找到它所指向的对象(a),pa存的是a的地址所以pa指向a,*pa其实就是a。
*pa = 20;就相当于 a = 20;将 a 的值改变了。
int main()
{
int a = 0;
int* pa = &a;
*pa = 20;
return 0;
}
指针变量的大小?
——4/8个字节,取决于编译器是x86环境还是x64环境
指针类型的意义
两件事情:
1.指针类型进行+1/-1的操作时,它会跳过几个字节。
2.进行解引用操作的时候,决定了解引用操作时候的权限,(访问多少个字节)
指针的运算
1。+-整数
2.指针-指针
3.指针的关系运算
指针数组
本质上就是数组,数组中存放的是指针(地址)。
arr 存放了三个元素,每个元素都是int*类型,也就是指针,那么arr就是指针数组。
int main()
{
int *pa;
int *pb;
int *pc;
int* arr = { pa,pb,pc };
return 0;
}
数组名是什么
1.数组名在大部分情况下表示数组首元素的地址,
但是有两个例外:
a)sizeof(数组名),表示的是整个数组的大小
b)&数组名,取出的是整个数组的地址
数组指针
&数组名,这里的parr ,存放的是数组的地址,parr为数组指针。
数组指针:int (*parr)[10],parr与*结合,代表parr为指针,[10]表示parr指向数组,数组中元素的类型是int。
指针数组:int* parr[10],没有括号,parr与[10]结合,表示parr为数组,数组中元素的类型是int*(整形指针)
数组指针类型的表示:int (*)[10];
int arr[10] = {1,2,3};
int (*parr)[10] = &arr;
函数指针
函数指针就是函数的地址,函数也有地址,我们可以通过函数的地址去使用函数。
函数的地址存放在函数指针变量中,
函数指针类型表示:
int (*)(int,int)
int (*pf)(int ,int),pf与*结合,表示pf是指针,指针指向的是(int , int)参数是两个整形的函数,函数的返回类型是int。
int Add(int x,int y)
{
return x + y;
}
int main()
{
int (*pf)(int ,int) = &Add;
int sum = (*pf)(2,3);
//Add 和 &函数名一样,Add也可以直接表示为地址,因此也可以写成这种形式
//int (*pf)(int ,int) = Add;
//Add传给了pf,pf 等同于 Add ,那么我们也可以这样写。
//int sum = pf(2.3)
return 0;
}
函数指针数组
存放函数指针的数组。
我们将函数指针数组命名为arr,arr数组的每个元素的类型是:int (*)(int,int)
函数指针数组的类型表示:
int (*[4])(int,int)
怎么理解这函数指针数组的形式?
arr与[4]结合,说明arr是数组,这个数字的每个元素是int(*)(int,int),而这正好是函数指针类型。
int (*arr[4])(int,int) = {Add,Sub,Div,Mul};
回调函数
通过函数指针调用的函数就是回调函数。
这里的函数指针是pf,pf指向的函数是Add,通过pf调用Add,我们称Add为回调函数。
int Add(int x,int y)
{
return x + y;
}
int main()
{
int (*pf)(int ,int) = Add;
int sum = pf(2.3);
return 0;
}
笔试题
一维数组
题目:
以下打印的结果分别是什么?
int a[] = {1,2,3,4};
1|printf("%d\n",sizeof(a));
2|printf("%d\n",sizeof(a+0));
3|printf("%d\n",sizeof(*a));
4|printf("%d\n",sizeof(a+1));
5|printf("%d\n",sizeof(a[1]));
6|printf("%d\n",sizeof(&a));
7|printf("%d\n",sizeof(*&a));
8|printf("%d\n",sizeof(&a+1));
9|printf("%d\n",sizeof(&a[0]));
10|printf("%d\n",sizeof(&a[0]+1));
数组名的理解,指针的运算和指针类型的意义
解析:
1.printf (" %d\n ", sizeof ( a ) ); 16
sizeof(数组名),数组名表示整个数组,计算的是整个数组的大小,单位是字节
2.printf (" %d\n ", sizeof( a+0 ) ); 4 / 8
a不是单独放在sizeof内部,也没有取地址,所以a就是首元素的地址,a+0还是首元素的地址。是地址,大小就是4 / 8个字节。地址的大小和环境有关,32位的系统环境就是4个字节,64位系统环境就是8个字节。
3.printf (" %d\n ", sizeof( *a ) ); 4
*a中的a是数组数组首元素的地址,*a就是对首元素的地址解引用,找到的就是首元素,
首元素是整形,所占内存大小是4个字节
4.printf (" %d\n ", sizeof( a+1 ) ); 4 / 8
a不是单独放在sizeof的内部,a表示的是首元素的地址,a+1就是数组第二个元素的地址
地址的大小是4个字节或者8个字节。
5.printf (" %d\n ", sizeof( a[1] ) ); 4
a[1]表示的是数组的第二个元素,作为整形元素的大小为4个字节
6.printf (" %d\n ", sizeof( &a ) ); 4 / 8
&a,&数组名,这里的a表示的是整个数组的地址,一共4个元素,地址的大小是4个字节。虽然说是整个数组的地址,但是还是通过首元素的地址来表达。
注意:首元素的地址和数组的地址虽然表现是同一个地址,但是它们的运算的结果是不一样的。
比如:&a+1和a+1,一个表示的是跳过了一个(4个整形元素的)数组的地址,一个表示的是数组第二个元素的地址
7.printf (" %d\n ", sizeof( *&a ) ); 16
&a取的是整个数组的地址,对&a进行解引用,得到的是整个数组,一共4个元素,一个整形元素的大小为4个字节,一共是16个字节
8.printf (" %d\n ", sizeof( &a+1 ) ); 4 / 8
&数组名,取的是整个数组的地址,&a再加上1,就是跳过一个数组的位置,然后再取了一个相同大小数组的地址。&a+1还是地址,地址的大小就是4 / 8个字节。
9.printf (" %d\n ", sizeof( &a[0] ) ); 4 / 8
&a[0]取的是数组第一个元素的地址,大小是4个字节或者8个字节。
10.printf (" %d\n ", sizeof( &a[0]+1 ) ); 4 / 8
&a[0],取的是数组第一个元素的地址,&a[0]+1就是数组第二个元素的地址。大小是4个字节或者8个字节。
总结:
1.数组名大多数表示首元素的地址,有两个例外:1.sizeof(数组名)2.&数组名。数组名表示的是整个数组 。
2.不同类型地址跳过的字节不一样,&a+1,&a表示的是整个数组,+1就会跳过一个数组的大小。&a[0]+1,&a[0]是数组第一个元素的地址,所以+1跳过的是一个元素的大小。
3.地址意义可能不同,但是地址的大小都是4 / 8个字节。
字符数组
题目1:
以下打印的结果是什么?
char arr[] = {'a','b','c','d','e','f'};
1|printf("%d\n",sizeof(arr));
2|printf("%d\n",sizeof(arr+0));
3|printf("%d\n",sizeof(*arr));
4|printf("%d\n",sizeof(arr[1]));
5|printf("%d\n",sizeof(&arr));
6|printf("%d\n",sizeof(&arr+1));
7|printf("%d\n",sizeof(&arr[0]+1));
解析:
1| printf (" %d\n " , sizeof ( arr ) ) 6
sizeof(数组名),取的是整个数组的大小,字符数组arr一共6个元素,所以大小为6个字节。
2|printf (" %d\n ", sizeof( arr+0 ) ) 4 / 8
arr并没有单独放在sizeof内部,所以arr表示首元素的地址,arr+0也表示首元素的地址。是地址,那么大小就为4个字节或者8个字节。
3|printf (" %d\n ",sizeof ( *arr ) ) 1
arr是首元素的地址,就是 ‘a’ 的地址,然后解引用,就是‘a’,char类型,大小是1个字节。
*arr 等价于arr [ 0 ]
*(arr+0) 等价于 arr [ 0 ]
4|printf (" %d\n ", sizeof( arr[1] ) ) 1
arr[1]是数组第二个元素,‘b',大小是1个字节。
5|printf (" %d\n ", sizeof( &arr ) ) 4 / 8
&arr取的是数组的地址,是地址就是4 / 8 个字节。
6|printf (" %d\n ", sizeof( &arr+1 ) ) 4 / 8
&arr取的是arr数组的地址,&arr+1跳过一个(6个字符元素的)数组,下图是&arr+1的地址位置,是地址,大小就是4个字节或者8个字节。
7|printf (" %d\n ", sizeof( &arr[0]+1 ) ) 4 / 8
&arr[0]取的是数组第一个元素的地址,&arr[0]+1就是第二个元素的地址,是地址,就是4个字节或者8个字节。
题目2:
以下的打印结果分别是什么?
char arr[] = {'a','b','c','d','e','f'};
1|printf("%d\n",strlen(arr));
2|printf("%d\n",strlen(arr+0));
3|printf("%d\n",strlen(*arr));
4|printf("%d\n",strlen(arr[1]));
5|printf("%d\n",strlen(&arr));
6|printf("%d\n",strlen(&arr+1));
7|printf("%d\n",strlen(&arr[0]+1));
解析:
strlen
用来求字符串长度的库函数,参数是地址,从参数传来的地址开始,直到有' \0 '停止。
1|printf (" %d\n ", strlen ( arr ) ) 随机值
arr为数组首元素的地址,字符数组没有' \0 ',strlen会运行完数组,还会继续运行,直到遇到' \0',但是数组外的元素不由数组控制,也就是说,' \0 '什么时候出现是不可知的,所以会打印随机值。
下图遇到' \0 '前一共19个元素,所以打印结果为19。
' \0 '的ASCII的数字就是0.
2|printf (" %d\n ", strlen ( arr+0 ) ) 随机值
arr+0也是首元素的地址,其实和前面问题的随机值是一样的。这里也将会在第20个元素遇到 ‘\0’,所以这里的随机值与 1| 一样。
3|printf (" %d\n ", strlen ( *arr ) ) 访问冲突
strlen的参数是地址,而*arr传过去的是 ’a‘ ,’a'的ASCII值为97,,不是一个地址,就会发生访问冲突,也就是野指针问题。
4|printf (" %d\n ", strlen ( arr[1] ) ) 访问冲突
和前面一个问题产生的结果一样,既然strlen函数的参数是地址,将值传过去就会产生野指针的问题。
5|printf (" %d\n ", strlen ( &arr ) ) 随机值
&arr传过去的是整个数组的地址,strlen用const char* str来接收,那么strlen又是怎么运行的呢?这里的地址和1|、2|类型不同,但是地址的位置是相同的,strlen也应该是从首元素开始一个一个筛查,直到遇到 ‘\0’ ,求字符串才算结束。所以这里和1|、2|的结果应该是一样的。
6|printf (" %d\n ", strlen ( &arr+1 ) ) 随机值 - 6
&arr+1,&arr取的是整个数组的地址,&arr+1会跳过一个(6个char类型元素的)数组,下图标记&arr+1的地址位置,strlen函数也就是从这里开始运行,直到遇到 ‘\0’ ,那么这里的结果就会比1|、2|、5|的结果少6个元素。结果:随机值 - 6
7|printf (" %d\n ", strlen ( &arr[0]+1 ) ) 随机值 - 1
&arr[0]取的是数组第一个元素的地址,&arr[0]+1就是数组第二个元素的地址,从第二个元素开始,strlen遇到 '\0' 停止,就会比1|、2|、5|的结果少1个元素。结果:随机值 - 1.
总结:
1.strlen(const char* str)传递的参数是地址,如果传递数值的话,就会产生访问冲突的问题。
2.strlen不管地址的类型,只管地址的位置,从地址的位置开始,逐个去数字符,直到遇到 \0 ,strlen就停止运行,求出字符串的长度。
题目3:
以下打印的结果是什么?
char arr[] = "abcdef";
1|printf("%d\n",sizeof(arr));
2|printf("%d\n",sizeof(arr+0));
3|printf("%d\n",sizeof(*arr));
4|printf("%d\n",sizeof(arr[1]));
5|printf("%d\n",sizeof(&arr));
6|printf("%d\n",sizeof(&arr+1));
7|printf("%d\n",sizeof(&arr[0]+1));
解析:
char arr[] = "abcdef",这个数组的元素为[ a b c d e f \0 ],一共7个元素,字符串默认以 \0 结尾。
1|printf (" %d\n ", sizeof ( arr ) ) 7
sizeof(数组名),这里的数组名表示的是整个数组,因为字符串默认为 ‘\0’ 结尾,所以这个数组有7个元素,结果为7个字节。
2|printf (" %d\n ", sizeof ( arr+0 ) ) 4 / 8
arr表示的是首元素的地址,arr+0表示首元素的地址,是地址,地址的大小为4个字节或者8个字节。
3|printf (" %d\n ", sizeof ( *arr ) ) 1
arr表示首元素的地址,*arr取的是‘a’,大小为1个字节。
4|printf (" %d\n ", sizeof ( arr[1] ) ) 1
arr[1]为数组的第二个元素,‘b’,大小为1个字节。
5|printf (" %d\n ", sizeof ( &arr ) ) 4 / 8
&arr取的是整个数组的地址,地址的大小为4个字节或者8个字节。
6|printf (" %d\n ", sizeof ( &arr+1 ) ) 4 / 8
&arr取的是整个数组的地址,&arr+1跳过1个(7个元素)的数组,跳过一个数组,但是地址的类型是不变的,是还是一个数组的地址,不过既然是地址,地址的大小为4个字节或者8个字节。
7|printf (" %d\n ", sizeof ( &arr[0]+1 ) ) 4 / 8
&arr[0]取的是数组第一个元素的地址,&arr+1就是数组第二个元素的地址,地址的大小为4个字节或者8个字节。
总结:
1.不管地址的类型是什么,只要是地址,地址的大小就是4个字节或者8个字节。
2.字符串相当于普通的字符数组,但是字符串通常默认 \0 为结尾。
3.sizeof 只关注占用内存空间的大小,不在乎内存中放的是什么。
题目4:
以下打印的结果是什么?
char arr[] = "abcdef";
1|printf("%d\n",strlen(arr));
2|printf("%d\n",strlen(arr+0));
3|printf("%d\n",strlen(*arr));
4|printf("%d\n",strlen(arr[1]));
5|printf("%d\n",strlen(&arr));
6|printf("%d\n",strlen(&arr+1));
7|printf("%d\n",strlen(&arr[0]+1));
解析:
char arr[] = "abcdef",这个数组的元素为[ a b c d e f \0 ],一共7个元素,字符串默认以 \0 结尾。
strlen是求字符串长度的,关注的是字符串中的 \0 ,计算的是 \0 之前出现的字符的个数。
1|printf (" %d\n" , strlen ( arr ) ) 6
arr是首元素的地址,遇到 \0 停止。结果:6
2|printf (" %d\n ", strlen ( arr+0 ) ) 6
3|printf (" %d\n ", strlen ( *arr ) ) 访问冲突
传递的不是地址。
4|printf (" %d\n ", strlen ( arr[1] ) ) 访问冲突
传递的不是地址。
5|printf (" %d\n ", strlen ( &arr ) ) 6
取的是整个数组的地址,但是地址位置是首元素的地址。
6|printf (" %d\n ", strlen ( &arr+1 ) ) 随机值
跳过了一个数组,\0也包括在这个数组里面,strlen就会往下去寻找 \0 ,结果会是随机值。
7|printf (" %d\n ", strlen ( &arr[0]+1 ) ) 5
从第二个元素开始,后面遇到 \0,一共是5个元素。
总结:
1. strlen是求字符串长度的,关注的是字符串中的 \0 ,计算的是 \0 之前出现的字符的个数。
2.sizeof 只关注占用内存空间的大小,不在乎内存中放的是什么。
题目5:
char* p = "abcdef";
1|printf("%d\n",sizeof(p));
2|printf("%d\n",sizeof(p+1));
3|printf("%d\n",sizeof(*p));
4|printf("%d\n",sizeof(p[0]));
5|printf("%d\n",sizeof(&p));
6|printf("%d\n",sizeof(&p+1));
7|printf("%d\n",sizeof(&p[0]+1));
答案:
这里的“abcdef”并不是数组,而是常量字符串,常量字符串在内存中有独立的地址。p接收的是首元素’a‘的地址。
1|printf (" %d\n ", sizeof ( p ) ) 4 / 8
p是 指针变量,存放的是’a‘的地址。地址的大小为4个字节或者8个字节。
2|printf (" %d\n ", sizeof ( p+1 ) ) 4 / 8
p+1是地址。
3|printf (" %d\n ", sizeof ( *p ) ) 1
*p是 ’a‘,大小是1个字节
4|printf (" %d\n ", sizeof ( p[0] ) ) 1
p[0]是’a‘,大小是1个字节。
5|printf (" %d\n ", sizeof ( &p ) ) 随机值
&p是地址,p是指针变量,p存放的是常量字符串首元素’a‘的地址,但是p的地址与常量字符串没有关系,p的地址属于二级指针,一级指针的地址。所以是随机值。
6|printf (" %d\n ", sizeof ( &p+1 ) ) 4 / 8
&p+1是地址。所以大小为4个字节或者8个字节。
7|printf (" %d\n ", sizeof ( &p[0]+1 ) ) 4 / 8
&p[0]+1是地址。&p[0]就是‘a’的地址,+1就是‘b’的地址。
题目6:
char* p = "abcdef";
1|printf("%d\n",strlen(p));
2|printf("%d\n",strlen(p+1));
3|printf("%d\n",strlen(*p));
4|printf("%d\n",strlen(p[0]));
5|printf("%d\n",strlen(&p));
6|printf("%d\n",strlen(&p+1));
7|printf("%d\n",strlen(&p[0]+1));
答案:
1|printf (" %d\n ", strlen( p ) ) 6
p是首元素‘a’的地址,往后6个元素,到 \0 停止。
2|printf (" %d\n ", strlen( p+1 ) ) 5
p+1是第二个元素的地址,往后5个元素,到 \0 停止。
3|printf (" %d\n ", strlen ( *p ) ) 访问冲突
strlen的参数为地址。
4|printf (" %d\n ", strlen ( p[0] ) ) 访问冲突
strlen的参数为地址。
5|printf (" %d\n ", strlen ( &p ) ) 随机值
p是一级指针,&p就是二级指针。p的地址和常量字符串“abcdef”没有关系。
6|printf (" %d\n ", strlen( &p+1 ) ) 随机值 - 1
&p取的是p的地址,&p指向p的下一位。
7|printf (" %d\n ", strlen ( &p[0]+1 ) ) 5
p[0]就是’a‘,&p[0]取出了’a‘的地址,&p[0]+1就是’b‘的地址。
strlen从’b‘开始往后数,一直数到 \0为止,一共是5个元素。