数组笔试题详解

数组笔试题解析

我们可以通过做题来加深我们对数组及相关知识的理解,下面的笔试题解答正确的关键在于下面这点,一定要牢记:
数组名是首元素地址,两种情况除外:
1.sizeof(数组名) , 这是这是计算整个数组的大小,单位是字节;
2.&数组名 , 得出的是整个数组的地址;
下面我们来做几组数组相关的笔试题:
例1:

#include<stdio.h>
int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));
	//a是数组名单独放在sizeof内部,计算的是整个数组的大小,单位字节,结果是16
	printf("%d\n", sizeof(a + 0));
	//a+0是数组名首元素地址,是地址就是4/8个字节(32位平台下4字节,64位平台下8字节)
	printf("%d\n", sizeof(*a));
	//*a是对首元素的解引用,拿到的是1,则大小为4字节
	printf("%d\n", sizeof(a + 1));
	//a+1是首元素地址+1,也就是数组第二个元素的地址,是地址就是4/8字节
	printf("%d\n", sizeof(a[1]));
	//a[1]是第二个元素,其大小为4字节
	printf("%d\n", sizeof(&a));
	//&a是整个数组的地址,是地址就是4/8个字节,&a的类型:int(*)[4]
	printf("%d\n", sizeof(*&a));
	//*&a是对整个数组的解引用,拿到的是整个数组的元素,结果是16字节,*&a->a->aizeof(a)
	printf("%d\n", sizeof(&a + 1));
	//&a+1跳过的是整个数组,指向的是整个数组后面的地址,是地址就是4/8字节
	printf("%d\n", sizeof(&a[0]));
	//&a[0]是对首元素取地址,是地址就是4/8字节
	printf("%d\n", sizeof(&a[0] + 1));
	//&a[0]+1是数组第二个元素的地址,是地址就是4/8字节
}

在32位平台下:

例2:

#include<stdio.h>
int main()
{
	//字符数组
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	//arr是数组名单独放在sizeof内部,计算的是整个数组的大小,结果是6字节
	printf("%d\n", sizeof(arr + 0));
	//arr是数组名没有单独放进sizeof内部,表示的是数组首元素地址,首元素地址+0,还是首元素地址
	//arr+0取的是数组的第一个元素的地址,是地址就是4/8字节
	printf("%d\n", sizeof(*arr));
	//*arr是对数组首元素的解引用,拿到的是'a',结果就是1字节
	printf("%d\n", sizeof(arr[1]));
	//arr[1]是第二个元素的大小,结果就是1字节
	printf("%d\n", sizeof(&arr));
	//&arr是整个元素的地址,是地址就是4/8字节
	printf("%d\n", sizeof(&arr + 1));
	//&arr+1是跳过整个数组,指向的是整个数组后面的地址,结果就是4/8字节
	printf("%d\n\n", sizeof(&arr[0] + 1));
	//&arr[0]+1是数组的第二个元素的地址,是地址就是4/8字节


	printf("%d\n", strlen(arr));
	//strlen只有遇到\0才结束,所以是随机值
	printf("%d\n", strlen(arr + 0));
	//arr+0是首元素地址,结果是4/8字节
	printf("%d\n", strlen(*arr));
	//strlen(*arr)->strlen('a')->strlne(97),非法访问内存,error
	printf("%d\n", strlen(arr[1]));
	//srtlen(arr[1])->strlen('b')->strlen(98),非法访问内存,error
	printf("%d\n", strlen(&arr));
	//随机值
	printf("%d\n", strlen(&arr + 1));
	//随机值
	printf("%d\n", strlen(&arr[0] + 1));
	//不知道什么时候会遇到\0,所以是随机值

}

例3:

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	//"abcdef" -> "abcdef\0"
	printf("%d\n", sizeof(arr));
	//arr是数组名,单独放在sizeof内部,计算的是整个数组的大小,结果是7字节
	printf("%d\n", sizeof(arr + 0));
	//arr+0是数组首元素的地址,结果是4/8
	printf("%d\n", sizeof(*arr));
	//*arr是对数组首元素的解引用,结果是1字节
	printf("%d\n", sizeof(arr[1]));
	//arr[1]是数组的第二个元素,结果是1字节
	printf("%d\n", sizeof(&arr));
	//&arr是整个数组的地址,结果是4/8字节
	printf("%d\n", sizeof(&arr + 1));
	//&arr+1是跳过整个数组,指向的是整个数组后的地址,结果是4/8字节
	printf("%d\n", sizeof(&arr[0] + 1));
	//&arr[0]+1是第二个元素的地址,结果就是4/8字节


	printf("%d\n", strlen(arr));
	//strlen(arr)是整个数组的个数,因为strlen不计算\0的大小,所以结果是6个
	printf("%d\n", strlen(arr + 0));
	//arr+0是第一个元素,向后数共6个
	printf("%d\n", strlen(*arr));
	//strlen(*arr)->strlen('a')->strlen(97),非法访问内存,error
	printf("%d\n", strlen(arr[1]));
	//strlen(*arr)->strlen('b')->strlen(98),非法访问内存,error
	printf("%d\n", strlen(&arr));
	//&arr是整个数组个数,结果是6个
	printf("%d\n", strlen(&arr + 1));
	//随机值,因为是跳过整个数组,指向的是整个数组后面,不知道什么时候会遇到\0,所以个数是不确定的
	printf("%d\n", strlen(&arr[0] + 1));
	//&arr[0]+1是第二个元素,向后数共5个,结果是5个
}

通过上面的笔试题我们知道:
1.strlen是求字符串的长度,计算的是’\0’之前的字符的个数，不包含’\0’
2.sizeof 的计算是包含’\0’的大小

例4:

#include<stdio.h>
int main()
{
	char* p = "abcdef";
	printf("%d\n", sizeof(p));
	//p是指针变量,存放的是地址,是地址就是4/8字节
	printf("%d\n", sizeof(p + 1));
	//p+1是第二个元素的地址,是地址就是4/8字节
	printf("%d\n", sizeof(*p));
	//*p是'a',计算的是'a'的大小,结果是1字节
	printf("%d\n", sizeof(p[0]));
	//p[0]是'a',计算的是'a'的大小,结果是1字节
	printf("%d\n", sizeof(&p));
	//&p是二级指针,是指针也是地址,指针大小就是4/8字节
	printf("%d\n", sizeof(&p + 1));
	//&p+1是跳过整个数组的地址,指向整个数组后的地址就,结果就是4/8字节
	printf("%d\n", sizeof(&p[0] + 1));
	//&p[0]+1是数组第二个元素的地址,是地址就是4/8字节


	printf("%d\n", strlen(p));
	//strlen(p)就是求p所指向的元素直到\0之前的元素个数,结果就是6个
	printf("%d\n", strlen(p + 1));
	//p+1是第二个元素,从第二个元素开始到\0之前的字符个数,结果是5个
	printf("%d\n", strlen(*p));
	//*p是a,strlen('a')->strlen(97),非法访问内存,error
	printf("%d\n", strlen(p[0]));
	//p[0]是a,strlen('a')->strlen(97),非法访问内存,error
	printf("%d\n", strlen(&p));
	//&p是p这个指针变量的起始地址,从起始地址到\0,不确定中间元素个数,所以是随机值
	printf("%d\n", strlen(&p + 1));
	//&p+1,跳过整个指针变量,指向的是整个指针变量后的地址,不确定什么时候能遇到\0,所以是随机值
	printf("%d\n", strlen(&p[0] + 1));
	//&p[0]+1是第二个元素,结果是5个
}

字符串里面默认有个’\0’,字符里面没有默认的’\0’,字符串是双引号括起来的,字符是单引号括起来的;
sizeof计算时会包含’\0’的计算,而strlen不会包含’\0’的计算;

例5:

#include<stdio.h>
int main()
{
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	//a是数组名,单独放在sizeof内部,是计算整个数组的大小,结果是48字节
	printf("%d\n", sizeof(a[0][0]));
	//a[0][0]是第一行第一个元素,结果是4字节
	printf("%d\n", sizeof(a[0]));
	//a[0]是单独放在sizeof内部的,a[0]代表第一行的数组名,计算的是第一行的大小,结果是16字节
	printf("%d\n", sizeof(a[0] + 1));
	//a[0]+1没有单独放在sizeof内部,所以a[0]就是a[0][0],+1则就是第一行第二个元素的地址,结果就是4/8字节
	printf("%d\n", sizeof(*(a[0] + 1)));
	//*(a[0]+1)就是对第一行第二个元素解引用,结果是4字节
	printf("%d\n", sizeof(a + 1));
	//a+1是第二行的地址,结果就是4/8字节
	printf("%d\n", sizeof(*(a + 1)));
	//*(a+1)就是对第二行解引用,结果就是16字节
	printf("%d\n", sizeof(&a[0] + 1));
	//&a[0]是取第一行的地址,+1就是第二行的地址,结果就是4/8字节
	printf("%d\n", sizeof(*(&a[0] + 1)));
	//*(&a[0]+1)是对第二行的解引用,结果就是16字节
	printf("%d\n", sizeof(*a));
	//*a是对第一行的 解引用,结果是16字节
	printf("%d\n", sizeof(a[3])); // 不会真实访问,会根据类型确定字节大小
	//a[3]是第四行的数组名,计算第四行的大小,结果是16字节
}

总结:

1.数组名是首元素地址,两种情况除外:
①sizeof(数组名) , 这是这是计算整个数组的大小,单位是字节;
②&数组名 , 得出的是整个数组的地址;

2.strlen是求字符串的长度,计算的是’\0’之前的字符的个数，不包含’\0’；

3.sizeof 的计算是包含’\0’的大小；

4.字符串里面默认有个’\0’,字符里面没有默认的’\0’,字符串是双引号括起来的,字符是单引号括起来的;

5.sizeof不会真实访问空间,是通过变量的类型来计算占用空间大小的;

6.放在sizeof内部的表达式不会参与真实计算;

7.sizeof是在编译期间进行的;真实参与计算的表达式实在运行期间执行的;