指针和数组笔试题解析

大家好，我们今天来学习有关于指针和数组的笔试题解析。

在之前的C语言学习中我们知道了数组名代表的是数组首元素的地址，而有两个例外，就是sizeof中和&符操作取的就是整个数组的地址，那么我们今天的学习重点就是这些关于数组和指针的习题讲解。

下面让我们看到一维数组的习题：

int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };
	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]));
	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));
	return 0;
}

在做这个题我们要知道：数组名a单独放在sizeof内部，数组名表示整个数组，计算的是整个数组的大小，单位是字节
第一个我们sizeof（a）操作，实际上就是整个数组的大小，因为一个整型是4个字节，那么整个数组就是16个字节。
第二个因为a不是单独放在sizeof中，也没有取地址符，那它代表的就是数组首元素的地址，a+0代表的就是首元素的地址，是地址的话就是4/8个字节。
第三个a并非单独放在sizeof内部，也没有&,所以数组名a是数组首元素的地址，*a 就是 首元素，大小就是4个字节 。*a == *(a+0) == a[0]
第四个a并非单独放在sizeof内部，也没有&，所以数组名a是数组首元素的地址,a+1就是第二个元素的地址，是地址的话就是4/8个字节。
第五个a[1]就是数组的第二个元素，这里计算的就是第二个元素的大小，单位是字节，也就是为4个字节。
第六个&a - 是取出数组的地址，但是数组的地址也是地址，是地址就是4/8个Byte，在这里我们需要注意数组的地址 和 数组首元素的地址 的本质区别是类型的区别，并非大小的区别，只要是地址大小就是4/8个字节。
第七个对数组指针解引用访问一个数组的大小，单位是字节，这里也就是访问这个数组的大小，这个数组有4个元素，一个元素的大小是4个字节，那这个数组的大小就是16个字节。
第八个&a数组的地址，&a+1还是地址，是地址就是4/8个字节。
第九个&a[0]是首元素的地址， 计算的是地址的大小 4/8 个字节。
第十个&a[0]是首元素的地址，&a[0]+1就是第二个元素的地址，大小4/8个字节。

看到我们程序运行的结果：

学到这里大家应该都明白了吧，那么我们就进行下一个习题讲解。

字符数组

int main()
{
	//字符数组
	char arr[] = { 'a','b','c','d','e','f' };
	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));
	return 0;
}

看到上面一维数组的讲解那么这个题是不是就迎刃而解了呢。

第一个题数组名单独放在sizeof中就是整个数组的大小，char型的大小是一个字节，所以整个数组的大小就是6个字节。
第二题数组名没有单独放在sizeof中也没有&所以就是首元素的地址，arr+0也相当于首元素的地址，是地址的话大小就是4/8个字节。
第三题代表的就是首元素的地址，那么对它解引用就是第一个元素的大小，也就是1个字节。
第四个就是求第一个元素的大小，单位是字节，所以就是1个字节。
第五个就是对数组名取地址，用了&那么就是整个数组的地址，所以是地址的话就是4/8个字节。
第六个和第五个差不多，只不过第六题里跳过了整个数组，取的仍然是地址，是地址的话就是4/8个字节。
第七个代表的就是数组中第二个元素的地址，是地址的话就是4/8个字节。

到这里的话，以大家的聪明肯定已经理解了，那我们就进入到下一个题的讲解。

strlen类型题

int main()
{
	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));
	return 0;
}

做这种题的时候我们要知道strlen计算的是/0之前的字符个数。
第一题因为我们数组中没有’/0’，所以我们算出来的是一个随机值。
第二题arr是首元素的地址, arr+0还是首元素的地址，因为数组中没有‘/0’,不知什么时候会碰到‘/0’,所以我们这里算出来也是随机值。
第三题对首元素的地址，对它解引用之后得到的是字符‘a’的Ascall值，站在strlen的角度，认为传参进去的’a’-97就是地址，97作为地址，直接进行访问，就是非法访问。
第四题这个和第三题是一样的，传参进去的是‘b’的Ascall值，所以也是非法访问。
第五题这里我们取的整个数组的地址我们对它进行访问的时候也是不知道什么时候回碰到‘/0’,所以也是随机值。
第六题我们也是一样的，不过这里是跳过整个数组开始访问，也是不知道在哪里会碰到‘/0’所以这里也是一个随机值。
第七题我们这里是取的第二个元素的地址，我们从第二个元素开始访问，但也是不知道什么时候碰到’/0’,所以得到的也是一个随机值。

下面就是字符串类型的习题了：

int main()
{
	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));
	return 0;
}

做这个题之前我们要明白这是一个字符串，最后一个字符的后面隐藏了一个’/0’。

第一个我们这里是求整个数组的大小，因为字符串里面有一个’/0’，所以我们这里打印的结果就是7个字节。
第二个这里表示的第二个元素的地址，所以是地址的话就是4/8个字节。
第三个因为这个里面的数组名表示的是首元素的地址，所以对它解引用操作求的是首元素的大小，所以大小是1个字节。
第四个表示的是数组中第二个元素，所以求它的大小就是1个字节。
第五个这里是&操作，所以代表的是整个数组的地址，是地址的话就是4/8个地址。
第六个也一样，跳过了整个数组，仍然取的是地址，是地址的话就是4/8个字节。
第七个这里是第二个元素的地址，所以大小也是4/8个字节。

让我们看看程序运行的结果吧。

字符串的strlen类型

int main()
{
	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));
	return 0;
}

第一个我们知道就是整个数组的大小就是6。
第二个是数组首元素的地址所以从首元素开始访问，所以是6。
第三个传的是首元素的Ascall值，所以是非法访问。
第四个传的是第二个元素的值，所以也属于非法访问。
第五个和第六个都是随机值。
第七个因为是第二个元素的地址，所以从第二个元素开始访问，所以大小就是5。

接下来就是我们最近学的火热的指针类型了

int main()
{
	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));
	return 0;
}

第一个 计算的是指针变量的大小，所以是4/8个字节。
第二个p+1代表的第二个元素的地址，所以大小是4/8个字节。
第三个对指针解引用得到是’a’所以是1个字节。
第四个因为 p[0]–> *(p+0) --> *p == ‘a’，所以也是一个字节。
第五个&p 是地址，所以是4/8个字节。
第六个4/8个字节，&p 是地址。
第七个代表的是第二个元素的地址，所以从第二个元素开始访问，所以就是5个字节。

接下来就是最后一个，二维数组的习题

int main()
{
	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]));
	return 0;
}

第一个数组名a单独放在了sizeof内存，表示整个数组，sizeof(a)计算的是数组的大小，单位是字节，所以是48个字节。
第二个a[0][0]是数组的第一行第一个元素，这里计算的就是一个元素的大小，单位是字节，所以是4个字节。
第三个a[0]是第一行这个一维数组的数组名，数组名单独放在了sizeof内部，/a[0]就表示整个第一行这个一维数组，sizeof(a[0])计算的整个第一行这个一维数组的大小，所以就是16个字节。
第四个a[0]并非单独放在sizeof内部，也没有&,所以a[0]表示第一行这个一维数组首元素的地址，也就是第一行第一个元素的地址，因为a[0] <—> &a[0][0]，所以a[0]+1 —> &a[0][1]，因为是地址所以就是4/8个字节。
第五个a[0] + 1是第一行第二个元素的地址，(a[0] + 1))就是第一行第二个元素，所以就是4个字节。
第六个a 作为二维数组的数组名，并没有单独放在sizeof内部，也没有&，a就是数组首元素的地址，也就是第一行的地址， a 的类型是 int()[4]，a+1 就是第二行的地址,类型是：int()[4]，所以是4/8个字节。
第七个a+1是第二行的地址,(a+1)就是第二行，计算的就是第二行的大小，另外一个角度理解：(a+1) – a[1]，sizeof(a[1]) - a[1]这个第二行的数组名，单独放在了sizeof内部，计算的是第二行的大小，所以就是16个字节。
第八个a[0]是第一行的数组名，&a[0]取出的是数组的地址，取出的是第一行这个一维数组的地址，类型就是int()[4]，&a[0]+1 就是第二行的地址,类型就是int()[4]，所以就是4/8个字节。
第九个(&a[0] + 1)得到的就是第二行，计算的就是第二行的大小，所以就是16个字节。
第十个a表示数组首元素的地址，也就是第一行的地址，*a 就是第一行，也就相当于是第一行的数组名，所以就是计算第一行的大小，大小就是16个字节。
第十一个这里我们要注意的是a[3]表示的是第四行的地址，但是我们只定义了三行，但是这里呢我们不算是越界，所以大小是16个字节。

最后让我们来看看程序运行的结果吧：

学完这里想必大家都非常的烧脑吧，那么我们今天就学到这里，谢谢大家。