目录
这节我们来总结一下指针和数组面试题。
在这节我们主要用到这样几个知识点：
1.数组名是数组首元素的地址。
但是有两个例外：
2.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
3.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
数组笔试题
第一组
//一维数组
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(a));
//计算的是数组的大小，单位是字节，int类型是4个字节，所以结果是16个字节printf("%d\n", sizeof(a + 0));
//a代表数组首元素地址，a+0仍然代表数组首元素地址，
//地址的大小统一是4/8个字节（取决于是X86还是X64环境）printf("%d\n", sizeof(*a));
//a代表数组首元素地址，*a表示对数组首元素地址解引用
//所以结果是计算首元素大小，结果为4printf("%d\n", sizeof(a + 1));
//a代表数组首元素地址，a+1代表跳过一个整形，代表第一个元素地址
//由于还是地址，所以大小仍然是4/8个字节printf("%d\n", sizeof(a[1]));
//a[1]代表数组第二个元素，所以结果为4printf("%d\n", sizeof(&a));
//&a代表数组的地址，为int(*)[4]类型
//但是不管怎么说，还是地址，所以仍然是4/8个字节printf("%d\n", sizeof(*&a));
//第一个角度：&a代表数组的地址，是int(*)[4]类型
//*&a对数组的地址进行解引用，表示数组名，sizeof(数组名)代表整个数组的大小，16
//第二个角度：*和&可以抵消，相当于啥也没干，*&a==a，这就是脱裤子放屁了,sizeof(a),所以是16printf("%d\n",sizeof(&a+1));
//&a表示数组的地址，&a+1跳过整个数组，得到下一个数组地址
//但是还是地址，4/8printf("%d\n",sizeof(&a[0]));
//&a[0]得到a[0]的地址，地址都是4/8printf("%d\n",sizeof(&a[0]+1));
//&a[0]是a[0]的地址，地址+1跳过地址类型长度
//得到的是a[1]的地址，但还是地址，4/8第二组
//字符数组
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));
//sizeof(数组名)统计的是数组的大小，单位是字节，6printf("%d\n", sizeof(arr+0));
//sizeof(arr+0)不属于这篇博客最开始说的两种情况，
//因此arr表示数组首元素地址，arr+0还是数组首元素地址，4/8printf("%d\n", sizeof(*arr));
//arr表示数组首元素地址，*arr表示对数组首元素地址解引用
//求的是数组首元素大小 大小是1个字节printf("%d\n", sizeof(arr[1]));
//计算arr[1]的大小，大小也是1个字节printf("%d\n", sizeof(&arr));
//&arr表示数组的地址，为char(*)[6]类型，
//数组地址也是地址,4/8printf("%d\n", sizeof(&arr+1));
//&arr表示数组的地址，&arr+1表示跳过1个数组大小的下一个数组的地址
//地址大小就是4/8printf("%d\n", sizeof(&arr[0]+1));
//&arr[0]表示arr中第一个元素的地址，再+1表示arr[1]的地址，4/8printf("%d\n", strlen(arr));
//strlen统计的是\0之前的字符个数，因为字符数组arr中没有\0,
//所以在求字符串长度的时候,会一直往后找，产生的结果就是随机值printf("%d\n", strlen(arr+0));
//arr+0表示数组首元素地址，和第一个一样，也是随机值printf("%d\n", strlen(*arr));
//*arr表示'a',其ASCII码值为97，strlen函数参数需要传一个地址
//当我们传递的是'a'时，'a'的ASCII码值就是97，那就是将97作为地址传参
//strlen就会从97这个地址开始统计字符串的长度，这就是非法访问了errprintf("%d\n", strlen(arr[1]));//errprintf("%d\n", strlen(&arr));
//&arr表示的数组的地址，数组的地址和数组首元素地址，值是一样的
//传给strlen后，依然是从第一个元素开始找\0,
//所以仍然是随机值printf("%d\n", strlen(&arr+1));//随机值printf("%d\n", strlen(&arr[0]+1));
//第二的元素的地址，结果也是随机值第三组
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));
//sizeof(数组名)计算的是数组的大小，单位是字节，大小是7个字节printf("%d\n", sizeof(arr+0));//大小是4/8
//这种不属于sizeof(arr)或&arr，所以这里arr表示数组首元素地址
//arr+0仍然表示数组首元素地址，sizeof(arr+0)计算的是地址的大小printf("%d\n", sizeof(*arr));//1
//这里的arr表示数组首元素地址，*arr表示数组第一个元素
//sizeof(*arr)计算的是数组首元素的大小printf("%d\n", sizeof(arr[1]));//1, arr[1]->*(arr+1),表示数组第二个元素
//计算的是数组第二个元素的大小printf("%d\n", sizeof(&arr));//4/8
//&arr这里是整个数组的地址，为char (*)[6]类型，地址就是4/8个字节printf("%d\n", sizeof(&arr+1));//4/8
//&arr表示数组的地址，&arr+1数组地址+1跳过一个数组，得到下一个数组的地址
//是地址就是4/8个字节printf("%d\n", sizeof(&arr[0]+1));//4/8
//&arr[0]表示数组首元素地址，&arr[0]+1表示数组第二个元素的地址
//是地址就是4/8个字节printf("%d\n", strlen(arr));//6
//计算的是字符串的大小，统计的是\0之前的字符个数printf("%d\n", strlen(arr+0));//6
//arr+0仍然是数组首元素地址，统计的是从arr+0开始，\0之前的字符个数printf("%d\n", strlen(*arr));//err
//*arr->'a'，'a'的ASCII码值为97，把97作为参数传给strlen，站在strlen的角度看，他把97看成一个地址，
//这属于非法访问printf("%d\n", strlen(arr[1]));//err
//arr[1]表示'b','b'的ASCII码值是98，站在strlen的角度看，认为98是地址，这属于非法访问printf("%d\n", strlen(&arr));//6
//&arr表示数组的地址，类型是char(*)[6],但是strlen的参数为const char*,这里会存在类型转换，尽管这样，&arr仍然指向字符串的起始位置，从这里开始统计字符，直到遇到\0printf("%d\n", strlen(&arr+1));//随机值
//&arr是数组的地址，&arr+1跳过一个数组，从这个地址开始统计字符个数，直到遇到\0,但是我们并不知道之后内存里什么时候遇到\0,因此是随机值printf("%d\n", strlen(&arr[0]+1));//5
//&arr[0]表示数组首元素地址，即'a'的地址，&arr[0]+1表示'b'的地址，从'b'这里开始统计字符个数,因此结果为5第四组
char *p = "abcdef";
printf("%d\n", sizeof(p));
//p是char* 类型的指针，大小4/8个字节printf("%d\n", sizeof(p+1));
//p+1指向b，仍然是地址，大小4/8printf("%d\n", sizeof(*p));//1
//p表示字符'a'的地址，*p表示'a',计算的是'a'所占字节的大小printf("%d\n", sizeof(p[0]));//1
//p[0]->*(p+0)->*p,同上一题printf("%d\n", sizeof(&p));//&p表示字符指针p的地址，大小是4/8个字节printf("%d\n", sizeof(&p+1));//4/8printf("%d\n", sizeof(&p[0]+1));//4/8
p[0]表示'a',&p[0]表示'a'的地址，&p[0]+1表示'b'的地址，是地址就是4/8个字节printf("%d\n", strlen(p));//6
p指向'a',strlen(p)统计的是'a'开始，\0之前的字符个数printf("%d\n", strlen(p+1));//5
//统计的是'b'开始，'\0'之前的字符个数printf("%d\n", strlen(*p));//err
//*p表示'a',a的ASCII码值是97，作为参数传给strlen，strlen会把97当做地址看，非法访问printf("%d\n", strlen(p[0]));//err
//p[0]->'a',同上一题printf("%d\n", strlen(&p));//随机值
//p表示'a'的地址,类型是char*，&p表示p的地址，类型是char**,strlen(&p)统计的是从&p开始，直到遇到\0的字符个数，因此是随机值printf("%d\n", strlen(&p+1));//随机值printf("%d\n", strlen(&p[0]+1));//5
//&p[0]表示'a'的地址，&p[0]+1表示'b'的地址，统计从'b'开始，只到遇到\0的字符个数第五组
//二维数组
int a[3][4] = {0};
printf("%d\n",sizeof(a));//48printf("%d\n",sizeof(a[0][0]));//4printf("%d\n",sizeof(a[0]));
//a[0]表示二维数组第一行的数组名，sizeof(数组名)j计算的是数组的大小，为16个字节printf("%d\n",sizeof(a[0]+1));
//arr[0]是数组名，没有单独放在sizeof内部，没有&，
//数组名表示数组首元素地址，也就是a[0][0]的地址，+1表示arr[0][1]的地址
//4/8printf("%d\n",sizeof(*(a[0]+1)));//4printf("%d\n",sizeof(a+1));//4/8
//a是数组首元素的地址，是第一行的地址，int(*)[4]
//a+1就是第二行的地址printf("%d\n",sizeof(*(a+1)));//16
//*(a+1)-->a[1]-->sizeof(*(a+1))-->sizeof(a[1])计算的第二行的大小
//a+1是第二行的地址，int(*)[4]
//*(a+1)访问第二行的值printf("%d\n",sizeof(&a[0]+1));//4/8
//&a[0]是第一行地址 int(*)[4]
//&a[0]+1是第二行的地址printf("%d\n",sizeof(*(&a[0]+1)));//16
//计算的是第二行的大小printf("%d\n",sizeof(*a));//16
//计算的是第一行的大小
//a是数组首元素的地址，就是第一行的地址
//*a就是第一行的数组名
//*a --> *(a+0) --> a[0]printf("%d\n",sizeof(a[3]));
//a[3]--> int [4]
//16指针笔试题
笔试题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,5
笔试题2
//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
int Num;
char* pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}第一个：p为结构体类型的指针，p+1跳过一个结构体类型，结构体大小是20个字节，所以0x100000+20 == 0x100014
第二个：把p转换为unsigned long,p就是无符号整形了，这时p+1表示真正加1,0x100001
第三个：把p强制转换成unsigned int*类型，p+1跳过unsigned int类型大小的字节，即+4,0x100004
00000014
00000001
00000004
笔试题3
int main()
{
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int*)(&a + 1);
int* ptr2 = (int*)((int)a + 1);
printf("%x,%x", ptr1[-1], *ptr2);
return 0;
}
4,2000000
笔试题4
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
int* p;
p = a[0];
printf("%d", p[0]);
return 0;
}特别注意：这道题数组初始化的时候是（ ，），这是逗号表达式（0,1）的结果是1，以此类推
1
笔试题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;
}
&p[4][2] - &a[4][2]：指针-指针计算的是指针之间元素的个数（-4）
//10000000000000000000000000000100
//1111111111111111111111111111111111011
//1111111111111111111111111111111111100---以%p的形式打印出来FFFFFFFC
//以%d形式打印出来的是补码，因此是-4
FFFFFFFC， -4
笔试题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;
}
10,5
笔试题7
#include <stdio.h>
int main()
{
char* a[] = { "work","at","alibaba" };
char** pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}
at
笔试题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;
}
POINT
ER
ST
EW
指针阶段到此结束，完结撒花！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
