征服C语言指针系列(1)重点笔试题详解

1.指针与数组结合题型

1.一维数组

1.1.sizeof和整型数组

先上代码,大家可以先自己做一下这些题,
注意:
1.在32位平台下,指针大小为4个字节,在64位平台下,指针大小为8个字节
2.在这里所说的指针就是地址,地址就是指针

	int a[] = { 1,2,3,4 };
	//1.
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a + 0));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(a[1]));
	//2.
	printf("%d\n", sizeof(&a));
	printf("%d\n", sizeof(*&a));
	printf("%d\n", sizeof(&a + 1));
	printf("%d\n", sizeof(&a[0]));
	printf("%d\n", sizeof(&a[0] + 1));

答案是
1.  16
	4或者8
	4
	4或者8
	4
2.	4或者8
	16
	4或者8
	4或者8
	4或者8

解析:
1.答案:16
知识点:
考查对于sizeof(数组名)的理解,
注意:数组名一般情况下代表数组首元素的地址,只有两种情况代表整个数组的地址:
(1).sizeof(数组名)
(2).&数组名
解析:
sizeof(数组名):求整个数组的大小(即所占字节数):4(数组元素个数)*4(int类型占4个字节的单位)=16

2.答案:4或者8:
注意:只有当sizeof(只有数组名这一个符号)时,sizeof(数组名)才代表整个求数组的大小
所以:此时a为数组首元素的地址,(a+0)为数组首元素的地址,而地址就是指针,就是4个字节或者8个字节

3.答案:4
此时:a为数组首元素的地址,*a为数组首元素,首元素为int类型,大小4个字节

4.答案:4或者8
与第二题如出一辙,只不过是代表数组第二个元素的地址

5.答案:4
a[1]代表数组第二个元素,为int类型,大小为4个字节

6.答案:4或者8
&a代表整个元素的地址,是地址,就是指针类型,就是4个或8个字节

7.答案:16
&a代表整个数组的地址,*&a等价于a,也就是说*&a就是a,所以等价于sizeof(a)也就是求整个数组的大小,也就是16个字节

8.答案:4或者8
&a+1,
&a+1,是地址,只要是地址大小就是4或者8个字节
补充:
其中&a的类型是int(*a)[4],也就是说&a的类型是一个数组指针,指向的数组的元素为int类型,数组元素的个数为4个,
所以:&a+1所"迈出的步长"为4个int类型,也就是说&a+1指向数组a末尾位置

9.答案:4或8
&a[0],是地址,所以大小为4或者8个字节
补充:
a[0]:数组首元素,&a[0]就是数组首元素的地址

10.答案:4或8
&a[0]+1,是地址,所以大小为4或者8个字节
补充:
&a[0]是数组首元素的地址,所以&a[0]+1就是数组第二个元素的地址

总结:
1.数组名一般情况下代表数组首元素的地址,只有两种情况代表整个数组的地址:
(1).sizeof(数组名)
(2).&数组名
2.sizeof(数组名):其中数组名代表整个数组的地址,那么为什么sizeof(数组名)不是计算地址的大小呢?
是sizeof这个操作符本身的特性,使得出现了这个特例
其实这个特例的出现才是sizeof用处最多的方面,
例如:在计算数组中所含元素个数时,我们就通常使用
int sz = sizeof(arr)/sizeof(arr[0]);来计算数组中所含元素个数
也就是说求一个类型所含字节大小才是sizeof设计的核心原因和用途,所以规定了sizeof(数组名)就是求整个数组的大小这么一个规定

补充:
&a是整个数组的地址,不过具体值还是数组首元素的地址,
只不过这个指针类型和a这个指针类型不同,前者是int(*)[4]类型,后者是int*类型

1.2.sizeof和字符数组

	//字符数组
	char arr[] = { 'a','b','c','d','e','f' };
	//1.
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	//2.
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));

答案:
1.	6
	4或8
	1
	1
2.	4或8
	4或8
	4或8

解析:
1.答案:6
sizeof(数组名):求整个数组的大小
arr一共只有6个元素,每个元素为char类型,所以计算结果为6*1=6
注意:
将arr与char arr[]="abcdef"相区分开来,
其中前者在数组末尾没有'\0',而后者有'\0'
补充:
1.使用sizeof 计算字符串大小时'\0'也会包含在所计算的字符串大小之内
2.strlen计算字符串长度时,遇到'\0'后才会停止,求得的长度不包含'\0'
---------------------------------------------------------------
2.答案:4或8
arr+0为数组首元素的地址,是地址,大小就为4或者8个字节

3.答案:1
arr是数组首元素的地址,*arr就是数组首元素,数组首元素为char类型,大小为1个字节

4.答案:1
arr[1]就是数组第二个元素,为char类型,大小为1个字节

5.答案:4或8
&arr:是整个数组的地址,是地址,大小就为4或者8个字节

6.答案:4或8
&arr+1:是整个数组末尾的地址,是地址,大小就为4或者8个字节

7.答案:4或者8
&arr[0]+1:是数组第二个元素的地址,是地址,大小就为4或者8个字节

其中第6,7题可见1.2sizeof和整型数组中的第8,10题的补充

> 补充:
> size_t strlen ( const char * str );
> 也就是说strlen的参数是一个char*类型的指针,
> 所以在计算一个字符串的长度的时候传入一个地址,
> strlen函数通过传入的地址开始依次往下开始读取地址所指向的内容
> 一直读到'\0',返回在读到'\0'之前的元素的个数

因为参数为char*类型,所以如果传入了其他类型的指针变量,均转化为char*类型,也就是限制了"指针变量的步长"为1

1.3 字符数组和strlen

	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));

在这里为了表示方便,我们假定随机值为x
答案是:
	x
	x
	非法访问
	非法访问
	x
	x-6
	x-1

解析:
1.答案:x.
上面提到过strlen只有读到'\0'时才会停止,而这种字符数组的末尾是不会自动追加'\0'的
所以strlen读到了该字符串末尾后发现没有'\0',所以继续向后读取知道读到了'\0',所以计算出的'\0'之前的字符个数为随机值x

2.答案:x.
传入的是arr+0,也就等同于传入arr,计算出从数组首元素开始往后读取到'\0'之前的字符个数,也就完全等同于第一题

3.答案:非法访问

前提知识:前面提到过:
1.arr代表数组首元素地址,*arr代表数组首元素
所以传入的是字符'a'
2.strlen的参数类型是char*,也就是需要传入一个地址,我们将字符'a'传入后,字符'a'在内存中实际存储的是字符'a'所对应得ascii码值,即97

题解:
所以strlen函数就认为97是个地址,于是访问97所对应的地址空间,
而97所对应的内存空间里面存放的是什么,是不清楚的,
有可能存放的是很重要的数据,所以不能被任意访问,
所以编译器会报错,因为操作系统为了保护电脑,不允许编译器访问这个地址空间,所以为非法访问

4.答案:非法访问
与第3题如出一辙,只不过传入的是arr[1],也就是数组第二个元素,即字符'b',所对应的ascii码值为98

5.答案:x
前置条件:前面补充过,详见1.1末尾补充内容
&arr是整个数组的地址,不过具体值还是数组首元素的地址,是不过这个指针类型和arr这个指针类型不同,前者是char(*)[6]类型,后者是char*类型

题解:
所以传入strlen这个函数的参数与传入arr这个参数所对应的值一样,
又因为前面提到过strlen的参数类型是char*,所以&arr被转化为char*类型,
限制了"指针变量的步长"为1
所以在strlen这个函数中传入&数组名和数组名和数组名+0,
三者本质上完全相同,没有差别

6.答案:随机值x-6
前面补充过,&arr的类型是char(*)[6]类型,
所以该指针变量的"步长"为6,所以&arr+1指向了数组末尾位置,
所以它是从f后面的地址开始计算,所以为x-6

7.答案:x-1
&arr[0]+1:就是数组第二个元素,所以strlen函数从数组第二个元素开始计算长度,所以少计算了字符'a'

1.4 字符串(另一类型的字符数组)与sizeof

	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));

答案:
注意:
这里的字符数组末尾有'\0',是C语言规定,编译器自动追加的,只不过没有显示出来而已

1.	7
	4或8
	1
	1
	4或8
	4或8
	4或8

解析
1.答案:7
前面提到过,sizeof(数组名):计算整个数组的大小,包括'\0'\

2.答案:4或8
arr+0是数组首元素的地址,是地址,大小就为4或8个字节

3.答案:1
*arr:数组首元素,为char类型,大小为1

4.答案:1
arr[1]:数组第二个元素,为char类型,大小为1

5.答案:4或8
&arr:整个数组的地址,是地址,大小就为4或8个字节

6.答案:4或8
&arr+1:整个数组末尾的地址,是地址,大小就为4或8个字节

7.答案:4或8
&arr[0]+1:数组第二个元素的地址,是地址,大小就为4或8个字节

1.5 字符串(另一类型的字符数组)与strlen

	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));

这里为了表示方便:随机值为x
答案:
	6
	6
	非法访问
	非法访问
	6
	x
	5

解析:
1.答案:6
前面提到过:strlen函数求'\0'之前的字符个数,这里为6个

2.答案:6
前面提到过,对于strlen函数而言,传入arr,arr+0,&arr,本质均相同,所以同第一题

3.答案:非法访问,同1.3的第三题

4.答案:非法访问,同1.3的第四题

5.答案:6,同第一题

6.答案:随机值x,
因为&arr+1是数组末尾的地址,也就是在这个字符串末尾的'\0'之后那个元素的首地址

7.答案:5
&arr[0]+1:数组第二个元素的地址,所以为6-1=5

1.5 指针指向的字符串与sizeof

补充:对于一个数组而言,以arr数组为例
int arr[]={1,2,3,4,5,6,7,8,9};
int i 代表从0到8的数字
arr[i] 就等价于 *(arr+i)
而且,同理,对于而言:
char* p = "abcdef";
p[i] 就等价于 *(p+i)

	char* p = "abcdef";
	printf("%d\n", sizeof(p));
	printf("%d\n", sizeof(p + 1));
	printf("%d\n", sizeof(*p));
	printf("%d\n", sizeof(p[0]));
	printf("%d\n", sizeof(&p));
	printf("%d\n", sizeof(&p + 1));
	printf("%d\n", sizeof(&p[0] + 1));

答案:
	4或者8
	4或者8
	1
	1
	4或者8
	4或者8
	4或者8

解析:
1.答案:4或者8
p就是数组首元素的地址,是地址,大小就为4或者8个字节

2.答案:4或者8
p+1是数组第二个元素的地址,是地址,大小就为4或者8个字节

3.答案:1
P是数组首元素的地址,*p就是数组的首元素,也就是字符'a',char类型,大小为1个字节

4.答案:1
前面补充过:p[i] 就等价于 *(p+i)
所以p[0]就是*(p+0),也就是*p,也就等同于第3题

5.答案:4或8
&p是指向指针p的二级指针,指针就是地址,大小就为4或者8个字节

6.答案:4或8
&p+1是指向指针p之后的空间的二级指针,指针就是地址,大小就为4或者8个字节.

7.答案:4或8
&p[0]+1是数组第二个元素的地址,是地址,大小就为4或者8个字节

我们可以通过这张图来仔细看一下:第5,6题

看红色箭头,也就是说,&p是指向p的二级指针,&p+1是指向p末尾的二级指针,但它们都是指针,是指针,大小就为4或8个字节

1.5 指针指向的字符串与strlen

	char* p = "abcdef";
	printf("%d\n", strlen(p));
	printf("%d\n", strlen(p + 1));
	printf("%d\n", strlen(*p));
	printf("%d\n", strlen(p[0]));
	printf("%d\n", strlen(&p));
	printf("%d\n", strlen(&p + 1));
	printf("%d\n", strlen(&p[0] + 1));

答案是:
	6
	5
	非法访问
	非法访问
	x
	y
	5

解析:
1. 答案:6
p是字符数组的首元素地址,
而把p传给strlen函数,也就是把字符数组首元素地址传给strlen,
所以strlen函数可以从字符'a'开始向后读取字符,一直读到'\0',所以答案为6

2.答案:5
p是char*类型的指针,"步长"为1,所以p+1就是数组第二个元素的地址也就是字符'b'的地址,所以从字符'b'开始向后读取直到'\0'

3.答案:非法访问,同1.3的第三题

4.答案:非法访问,同1.3的第四题,只不过这里指向的还是第一个元素,因为走的步长为0

5.答案:随机值x
注意:请与1.3的第5题区分开来,在后面我们看一下"内存图"

6.答案:随机值y
在后面我们看一下"内存图"

7.答案:5
&p[0]+1,数组第二个元素的地址,同第二题

从这里我们可以看出&p指向的地方的元素是未知的,
所以strlen(&p)和strlen(&p+1)求出的分别是随机值x和随机值y,
分别对应蓝色箭头和紫色箭头,
其中随机值x和随机值y无必然联系,
也就是说如果p内存在'\0',则x和y无任何关系,
如果p内不存在'\0',则x和y满足:x=y+6

注意:
这里所说的'\0',
因为'\0'的ASCII码值为0,而字符在内存中是以ASCII码值的形式存在的,
所以说只要p内存在0即表示存在'\0'

2.二维数组

首先:我们先说一下两个很好的关于二维数组理解方法

1.二维数组是一维数组,只不过二维数组的元素是一维数组,而一维数组的元素是int/char/double…类型

2.在同类型的情况下,对指针解引用就是得到指针所指向的目标

	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a[0][0]));
	printf("%d\n", sizeof(a[0]));
	printf("%d\n", sizeof(a[0] + 1));
	printf("%d\n", sizeof(*(a[0] + 1)));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(*(a + 1)));
	printf("%d\n", sizeof(&a[0] + 1));
	printf("%d\n", sizeof(*(&a[0] + 1)));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a[3]));

答案:
	48
	4
	16
	4或8
	4
	4或8
	16
	4或8
	16
	16
	16

解析:
1.答案:48
a是整个二维数组的地址,sizeof(a)就是求整个二维数组的大小
3*4*4=48

2.答案:4
a[0][0]:就是二维数组第一行的第一个元素,是int类型,大小为4字节

3.答案:16
a[0]:就是二维数组首元素的地址,而二维数组的首元素是一个一维数组,
所以a[0]就是这个一维数组的地址,所以sizeof(a[0])就是求这个一维数组的大小,即16

4.答案:4或8
a[0]是第一个一维数组的首元素的地址,
a[0]+1就是该一维数组第二个元素的地址,
是地址,大小就是4或者8个字节

5.答案;4
*(a[0]+1)就是第一个一维数组的第二个元素,为int类型,大小为4个字节

6.答案:4或8
a是二维数组首元素的地址,
a+1就是二维数组第二个元素的地址,就是第二个一维数组的地址
是地址,大小就是4或者8个字节

7.答案;16
a+1是第二个一维数组的地址,*(a+1)就是第二个一维数组,
sizeof(数组名)就是求整个数组的大小,
也就是说sizeof(*(a+1))就是求第二个一维数组的大小,也就是16

8.答案:4或者8
法一:内存理解:
本题后面给大家画了"内存图",其中&a[0]+1和a[0]+1所指向空间的起止位置都已经给大家标出来了,所以每个均有两个箭头,
&a[0]+1是指向了第二个一维数组的数组指针,其"步长"为4*4=16byte
法二:概念理解
前面说过:a[0]等价于*(a+0),所以&a[0]+1就等价于&*(a+0)+1,
也就等价于(a+0)+1 ,也就等价于a+1
其实&a[0]+1  等价于a+1  无论a是一维数组还是二维数组!!!!!!!!!!

总之,&a[0]+1是指针,指针式地址,地址就是4或8个字节

9.答案:16
由第八题概念法得:其实*(&a[0]+1)就是*(a+1),也就是a[1]

10.答案:16
其实*a就是*(a+0)就是a[0]

11.答案:16
a[i]是第i个一维数组的地址,sizeof(a[i])就是求第i个一维数组的大小,即16

注意:尽管a[3]并不存在(因为a是三行四列的二维数组,没有第四行),
但是sizeof(表达式),其中表达式并不参与运算,
也就是说表达式只负责告诉sizeof:(我是什么类型的数据,你只需要根据我的数据类型来计算字节数即可)
我们可以看下面的一个代码,它能够帮助你有更深刻的理解

第8题的图片

第11题的补充

void exam009()
{
	//sizeof()内部的表达式是不算的
	short s = 5;
	int a = 4;
	printf("%d\n", sizeof(s = a + 6));//2
	//说明了:这里不会因为a+6是int类型就将short改为int类型!!
	printf("%d\n", s);//5,也就说明了:并未进行sizeof()内部的表达式
}

总结:
1.sizeof()内部的表达式是不算的,
也就是说表达式只负责告诉sizeof:(我是什么类型的数据,你只需要根据我的数据类型来计算字节数即可)

2.其实&a[0]+1  等价于a+1  无论a是一维数组还是二维数组!!!!!!!!!!

3.重申一遍

> 1.二维数组是一维数组,只不过二维数组的元素是一维数组,而一维数组的元素是int/char/double.......类型

> 2.在同类型的情况下,对指针解引用就是得到指针所指向的目标

2.指针经典笔试题详解

1.

考点:
1.内存图
2.指针类型决定步长

void exam010()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	int* ptr = (int*)(&a + 1);
	printf("%d,%d", *(a + 1), *(ptr - 1));
}

答案是:2,5
> &a是数组指针类型,即int(*)[5],步长为4*5=20byte,
> 所以&a+1就指向了数组末尾的位置,
> 而强制类型转换为int*类型后,步长变为4,所以指向了最后一个元素的起始位置,所以*(ptr-1)就是最后一个元素

2.

考点:
指针类型决定了指针加减运算的步长

struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节,%p是打印地址
void exam011()
{
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
}

答案是:
0x100014
0x100001
0x100004

第一行:p是struct Test*类型的指针,又因为Test结构体的大小是20个字节,
所以步长为20,转为16进制是14

第二行:p强制类型转换为(unsigned long)类型,
unsigned long就是整型,整型加1就相当于1+1,所以答案就是0x100001

第三行:p强制类型转换为(unsigned int*)类型,步长为4,所以加4

3.

考点:
指针类型决定了指针的加减整数运算的步长
大小端存也要大小端取(具体大小端的知识可以看我的另一篇博客,里面深度剖析了数据在内存中的存储方式,当然也包括了非常详细的大小端问题的说明

https://blog.csdn.net/Wzs040810/article/details/130900893?spm=1001.2014.3001.5501

void exam012()
{
	int a[4] = { 1, 2, 3, 4 };
	int* ptr1 = (int*)(&a + 1);
	int* ptr2 = (int*)((int)a + 1);
	printf("%x,%x", ptr1[-1], *ptr2);
}

从中我们可以看出ptr2指向的数据取出来后是02 00 00 00,
所以将其转为16进制就是最终答案,
因为int* ptr2 = (int*)((int)a + 1)中我们先将a强制类型转换为了int类型,
所以加1操作就是将地址加一,也就是将地址加一个字节,
而int类型占4个字节,所以前移四分之一,指向了图中所示位置.

4.

考点:
逗号表达式
二维数组与指针

void exam013()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
	int* p;
	p = a[0];
	printf("%d", p[0]);
}

答案:1
注意:这里的二维数组不是
0 1
2 3
4 5
而是
1 3
5 0
0 0
因为逗号表达式整体的最终取值为逗号表达式的最后一项,不过每个表达式都会执行.
例如
int main()
{
	int b = 9;
	int a = (0, b = 20, 6 - 3);
	printf("%d %d", a, b);
	return 0;
}
//最终a的值为3
//b的值为20
而p就是第一个一维数组,p[0]就是第一个一维数组的第一个元素,也就是1

5.

考点:
内存图
指针的类型决定加减运算的步长

void exam014()
{
	int a[5][5];
	int(*p)[4];
	p = a;
	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
}

答案:FFFFFFFFFFFFFFFC,-4
其中FFFFFFFFFFFFFFFC是-4的补码的16进制表示形式

解析:
p[4][2]  == *(*(p+4)+2)
由图可以看出具体的过程,
p=a这一句的含义是:
a是二维数组首元素的地址,也就是第一个一维数组的地址,
也就是说a是一个数组指针,其类型为int(*)[5],
而p的类型是int(*)[4],尽管二者类型不同,但是a最终还是将第一个一维数组的地址传给了p
而p的类型不变,a的类型不变
p的步长为4*4=16byte
a的步长为5*4=20byte,

6.

考点:
二维数组
内存图

void exam015()
{
	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* ptr1 = (int*)(&aa + 1);
	int* ptr2 = (int*)(*(aa + 1));
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
}

答案是:10,5
注意:1.*(aa+1)等价于aa[1]
&aa是整个二维数组的地址,所以&aa+1后就指向了整个二维数组的末尾
2.定义ptr1和ptr2之前已经进行了强制类型转换,
将&aa+1和*(&aa+1)均转换为int*类型了,
所以后来进行指针的加减运算时步长为4byte

7.

考点:
内存图
二级指针
指针数组

void exam016()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
}

答案是:at,从图中就可以看出来,注意:printf("%s")打印时,
传入字符串首元素的地址即可,下面这一题就会用到这个知识点

8.

考点
内存图
多级指针

void exam017()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3,c + 2,c + 1,c };
	char*** cpp = cp;
	printf("%s\n", **++cpp);
	printf("%s\n", *-- * ++cpp + 3);
	printf("%s\n", *cpp[-2] + 3);
	printf("%s\n", cpp[-1][-1] + 1);
}

注意:所有的最外面的加减的常数在最后一步进行!!!!!!!!
可以简化代码
printf("%s\n", *cpp[-2] + 3);//**(cpp-2)+3
printf("%s\n", cpp[-1][-1] + 1);//*(*(cpp-1)-1)+1

c 以上就是征服C语言指针系列(1),希望能对大家有所帮助