指针和数组笔试题解析(含丰富例题及详细解析)

1.数组笔试题

1.1 一维数组

#include<stdio.h>
//1. sizeof(数组名)，数组名表示整个数组。计算的是整个数组的大小，单位是字节
//2.&数组名，数组名表示整个数组，取出的是整个数组的地址
//除此之外，所以的数组名都是首元素的地址

int main()
{
	int a[] = { 1,2,3,4 };//a数组有4个元素，每个元素有4个字节 4*4 = 16
	printf("%d\n", sizeof(a));//16
	printf("%d\n", sizeof(a + 0));//a未单独放入sizeof内部，a此时表示首元素地址 a+0还是首元素地址 4/8
	printf("%d\n", sizeof(*a));//同上，未单独放入，*a表示首元素，内容是整型 4
	printf("%d\n", sizeof(a + 1));//同上，表示第二元素地址 地址 4/8
	printf("%d\n", sizeof(a[1]));//数组第二个元素 4
	printf("%d\n", sizeof(&a));//&数组名，表示整个数组的地址，地址大小就是4/8
	printf("%d\n", sizeof(*&a));//&a是数组地址，*&a就是拿到了数组，*&a-->a 16
	//sizeof(*&a)-->sizeof(a) 计算的是整个数组大小 16

	printf("%d\n", sizeof(&a + 1));//&a整个数组，&a+1跳过整个数组，指向数组后面空间，是地址 4/8
	printf("%d\n", sizeof(&a[0]));//首元素的地址， 4/8
	printf("%d\n", sizeof(&a[0] + 1));//首元素地址+1，第二个元素地址 4/8
	return 0;
}

1.2 字符数组

字符串结尾未放入 \0

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };//数组内6个元素
	printf("%d\n", sizeof(arr));//arr单独放入，计算整个数组的大小 6
	printf("%d\n", sizeof(arr + 0));//arr+0是数组首元素地址 地址 4/8
	printf("%d\n", sizeof(*arr));//*arr，数组首元素 1
	printf("%d\n", sizeof(arr[1]));//第二元素 1
	printf("%d\n", sizeof(&arr));//&arr，取出的是数组的地址 地址 4/8
	printf("%d\n", sizeof(&arr + 1));//整个数组+1，跳过整个数组，指向后面的空间，是地址 4/8
	printf("%d\n", sizeof(&arr[0] + 1));//首元素地址+1，第二个元素地址 地址 4/8

	//strlen求字符串长度，本质上传的是地址，从起始地址开始算，遇到'\0'停止
	printf("%d\n", strlen(arr));//随机值
	printf("%d\n", strlen(arr + 0));//和上面意思一样 随机值
	printf("%d\n", strlen(*arr));//strlen('a')-->strlen(97)，非法访问 - err
	printf("%d\n", strlen(arr[1]));//同上，非法访问 - err
	printf("%d\n", strlen(&arr));//&arr取出的是数组的地址 随机值
	printf("%d\n", strlen(&arr + 1));//&arr+1跳过整个数组的地址，求的还是随机值
	printf("%d\n", strlen(&arr[0] + 1));//首元素地址+1，从第二元素开始求字符串长度，还是随机值
	return 0;
}

字符串结尾有 \0

int main()
{
	//sizeof()只关注占用内存空间的大小，单位是字节，不关心内存中存放的是什么
	//sizeof()是操作符
	//strlen() 求字符串长度，统计的是'\0'之前出现的字符个数，一定要找到'\0'才算结束，所以可能存在越界访问
	//strlen()是库函数
	char arr[] = "abcdef";//[a b c d e f \0]
	printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部，计算的是数组的总大小 7 byte
	printf("%d\n", sizeof(arr + 0));//arr+0是首元素地址，地址 4/8 byte
	printf("%d\n", sizeof(*arr));//*arr数组首元素 ，1 byte
	printf("%d\n", sizeof(arr[1]));//数组第二个元素，1 byte
	printf("%d\n", sizeof(&arr));//取出整个数组的地址 地址 4/8 byte
	printf("%d\n", sizeof(&arr + 1));//跳过整个数组的地址 地址 4/8 byte
	printf("%d\n", sizeof(&arr[0] + 1));//第二个元素的地址 地址 4/8 byte

	printf("%d\n", strlen(arr));//arr是数组首元素的地址，strlen从首元素的地址开始统计'\0'之前出现的字符个数，长度是 6
	printf("%d\n", strlen(arr + 0));//arr+0是数组首元素的地址 6
	printf("%d\n", strlen(*arr));//*arr是'a',ASCII码值是97，传的是非法地址 - err
	printf("%d\n", strlen(arr[1]));//意思同上 - err
	printf("%d\n", strlen(&arr));//类型不匹配，但strlen函数还是从首元素地址开始计算 6
	printf("%d\n", strlen(&arr + 1));//跳过整个数组，随机值
	printf("%d\n", strlen(&arr[0] + 1));//传的是第二个元素地址，从第二个元素往后统计字符串的长度 5
	return 0;
}

字符指针

int main()
{
	const char* p = "abcdef";
	printf("%d\n", sizeof(p));//p是指针变量，大小是4/8 byte
	printf("%d\n", sizeof(p + 1));//p+1是b的地址，地址 4/8 byte
	printf("%d\n", sizeof(*p));//*p是'a',计算字符大小 1 byte
	printf("%d\n", sizeof(p[0]));//p[0]-->*(p+0)-->*p ，同上 1 byte
	printf("%d\n", sizeof(&p));//取的是指针的地址，二级指针，还是地址 4/8 byte
	printf("%d\n", sizeof(&p + 1));//意思同上 4/8 byte
	printf("%d\n", sizeof(&p[0] + 1));//p[0]-->a-->&a拿到的是a的地址,a的地址+1是b的地址 地址 4/8 byte

	printf("%d\n", strlen(p));//6 求字符串长度 标准的求字符串长度
	printf("%d\n", strlen(p + 1));//p+1是b的地址，从b开始 长度是 5
	printf("%d\n", strlen(*p));//*p-->a 非法 err
	printf("%d\n", strlen(p[0]));//p[0]-->a 同上 err
	printf("%d\n", strlen(&p));//&p是取出p的地址 二级指针 随机值
	printf("%d\n", strlen(&p + 1));//意思同上 随机值
	printf("%d\n", strlen(&p[0] + 1));//&p[0]-->&a a的地址加1，从b的地址向后数字符串的长度 5
	return 0;
}

1.3 二维数组

int main()
{
	int a[3][4] = { 0 };//3行4列的二维数组，12个元素，类型为int
	printf("%d\n", sizeof(a));//48 
	printf("%d\n", sizeof(a[0][0]));//第一行第一个元素 4
	printf("%d\n", sizeof(a[0]));//a[0]是第一行的数组名，数组名单独放在sizeof内部，计算的是第一行所以元素的大小 4*4 = 16
	printf("%d\n", sizeof(a[0] + 1));//a[0]作为第一行的数组名，没有单独放在sizeof内部，没有&，表示数组首元素地址
	//那就是a[0][0]的地址，a[0]+1,就是第一行第二个元素的地址 地址4/8

	printf("%d\n", sizeof(*(a[0] + 1)));//第一行第二个元素 4
	printf("%d\n", sizeof(a + 1));//数组名未单独放入sizeof，表示首元素地址，就是第一行的地址，a+1就是第二行地址
	//地址 4/8  a+1 --> int(*)[4]类型是数组指针

	printf("%d\n", sizeof(*(a + 1)));//a+1是第二行地址，*(a+1)表示第二行 16
	printf("%d\n", sizeof(&a[0] + 1));//&a[0]取的是第一行的地址，&a[0]+1是第二行地址 地址 4/8
	printf("%d\n", sizeof(*(&a[0] + 1)));//*(&a[0] + 1)第二行地址解引用，是第二行，计算的第二行大小 16
	printf("%d\n", sizeof(*a));//未单独放入，表示首元素地址(第一行地址)，计算第一行大小 16
	printf("%d\n", sizeof(a[3]));
	//如果数字存在第四行，a[3]就是第四行的数组名 16
	//sizeof内部的表达式不会实际参与运算，数组虽然越界，但是不会访问
	return 0;
}

关于sizeof的小贴士:
sizeof内部表达式不会参与运算

小结

数组名的意义：

1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
3. 除此之外所有的数组名都表示首元素的地址。

2. 指针笔试题

笔试1

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

解析：

笔试题2

struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000，运行环境为x86。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
	p = (struct Test*)0x100000;
	printf("%p\n", p + 0x1);
	//p是结构体指针 0x1-->1 指针+1就是跳过20个字节 
	//0x00100014
	printf("%p\n", (unsigned long)p + 0x1);
	//强制类型转换为unsigned long类型，整型+1就是直接加上去
	//0x00100001
	printf("%p\n", (unsigned int*)p + 0x1);
	//强制类型转换为unsigned int*类型，整型指针+1，跳过4个字节
	//0x00100004
	return 0;
}

笔试3

//小端存储 x86环境
int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int *ptr1 = (int *)(&a + 1);
    printf( "%x,%x", ptr1[-1], *ptr2);
    return 0;
}

解析：

笔试4

int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    //这里是个陷阱，看似二维数组了放了6个元素，但是这里是小括号，是三个逗号表达式
    //真是存储的是{1, 3, 5},未完全初始化
    int* p;
    p = a[0];
    printf("%d", p[0]);
    return 0;
}

笔试5

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

解析：

笔试6

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

解析：

笔试7

//原阿里巴巴的一道笔试题
int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

解析：

笔试8

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

解析：
（原谅我这混乱的画风）

3.结语

   ~~   通过这些题目，其实可以感受到，指针的魅力真的很大，通过指针操作我们的程序，可以变得十分灵活，但是嘞，在刷题的时候，多画一画图，这样思路会更加清晰。