目录
巩固基础
1、一维数组
2、字符数组
3、字符串
4、二维数组
进阶提升
text1
text2
text3
text4
text5
text6
text7
巩固基础
sizeof只关注占用空间的大小,单位是字节
sizeof不关注类型
sizeof是 *** 作符
strlen关注的字符串中的为止,计算的是之前出现了多少个字符
strlen指针对字符串
strlen是库函数
指针的大小是固定的4/8个字节(32位平台/64位平台)
//魔鬼细节:答案由vs2019和dev两个不同编译器得出(有的题目在不同编译器和不同电脑结果不同!!)
1、一维数组int a[] = {1,2,3,4}; printf("%dn",sizeof(a)); printf("%dn",sizeof(a+0)); printf("%dn",sizeof(*a)); printf("%dn",sizeof(a+1)); printf("%dn",sizeof(a[1])); printf("%dn",sizeof(&a)); printf("%dn",sizeof(*&a)); printf("%dn",sizeof(&a+1)); printf("%dn",sizeof(&a[0])); printf("%dn",sizeof(&a[0]+1));
解析:
#includeint main() { int a[] = { 1,2,3,4 }; printf("%dn", sizeof(a));//数组名a单独放在sizeof内部,计算的整个数组的大小,单位是字节,4*4 = 16 printf("%dn", sizeof(a + 0));//a表示的首元素的地址,a+0还是数组首元素的地址,是地址大小4/8 printf("%dn", sizeof(*a));//a表示的首元素的地址,*a就是对首元素的地址的解引用,就是首元素,大小是4个字节 printf("%dn", sizeof(a + 1));//a表示的首元素的地址,a+1是第二个元素的地址,是地址,大小就4/8个字节 printf("%dn", sizeof(a[1]));//a[1]是数组的第二个元素,大小是4个字节 printf("%dn", sizeof(&a)); //&a 表示是数组的地址,数组的地址也是地址,地址大小就是4/8字节 printf("%dn", sizeof(*&a));//可以理解为*和&抵消效果,*&a相当于a,sizeof(a)是16 //&a -> int(*)[4] //&a是数组的地址,它的类型是int(*)[4]数组指针,如果解引用,访问的就是4个int的数组,大小是16个字节 printf("%dn", sizeof(&a + 1));//&a是数组的地址,&a+1 跳过整个数组后的地址,是地址就是4/8 printf("%dn", sizeof(&a[0]));//&a[0]取出数组第一个元素的地址,是地址就是4/8 printf("%dn", sizeof(&a[0] + 1));//&a[0]+1就是第二个元素的地址,是地址大小就是4/8个字节 //&a[0] -> int* , int*+1跳过一个整形 return 0; }
答案是(我的电脑是64位平台)
2、字符数组char a[] = {'a','b','c','d','e','f'}; printf("%dn",sizeof(a)); printf("%dn",sizeof(a+0)); printf("%dn",sizeof(*a)); printf("%dn",sizeof(a[1])); printf("%dn",sizeof(&a)); printf("%dn",sizeof(&a+1)); printf("%dn",sizeof(&a[0]+1));
char a[] = {'a','b','c','d','e','f'}; printf("%dn",strlen(a)); printf("%dn",strlen(a+0)); printf("%dn",strlen(*a)); printf("%dn",strlen(a[1])); printf("%dn",strlen(&a)); printf("%dn",strlen(&a+1)); printf("%dn",strlen(&a[0]+1));
解析1:
#include#include int main() { //字符数组 char arr[] = { 'a','b','c','d','e','f' }; printf("%dn", sizeof(arr));//arr作为数组名单独放在sizeof内部,计算的整个数组的大小,单位是字节,6 printf("%dn", sizeof(arr + 0));//arr就是首元素的地址,arr+0还是首元素的地址,地址大小就是4/8 printf("%dn", sizeof(*arr));//arr就是首元素的地址,*arr就是首元素,是一个字符,大小是一个字节,1 printf("%dn", sizeof(arr[1]));//arr[1]就是数组的第二个元素,是一个字符,大小是1个字节 printf("%dn", sizeof(&arr));//&arr取出的是数组的地址,数组的地址也是地址,地址就是4/8个字节 printf("%dn", sizeof(&arr + 1));//&arr取出的是数组的地址,&arr+1,跳过了整个数组,&arr+1还是地址,地址就是4/8个字节 printf("%dn", sizeof(&arr[0] + 1));//&arr[0]是第一个元素的地址,&arr[0]+1就是第二个元素的地址,地址就是4/8个字节 return 0; }
答案:
解析2:
#include#include int main() { //字符数组 char arr[] = { 'a','b','c','d','e','f' }; printf("%dn", strlen(arr));//arr是首元素的地址,但是arr数组中没有,计算的时候就不知道什么时候停止,结果是:随机值 printf("%dn", strlen(arr + 0));//arr是首元素的地址,arr+0还是首元素的地址,结果是:随机值 printf("%dn", strlen(*arr)); //err,strlen需要的是一个地址,从这个地址开始向后找字符,直到,统计字符的个数。 //但是*arr是数组的首元素,也就是'a',这是传给strlen的就是'a'的ascii码值97,strlen函数会把97作为起始地址,统计字符串,会形成内存访问冲突 printf("%dn", strlen(arr[1]));//err 和上一个一样,内存访问冲突 printf("%dn", strlen(&arr));//&arr是arr数组的地址,虽然类型和strlen的参数类型有所差异,但是传参过去后,还是从第一个字符的 //位置向后数字符,结果还是随机值。 printf("%dn", strlen(&arr + 1));//随机值 printf("%dn", strlen(&arr[0] + 1));//随机值 return 0; }
答案见解析;
3、字符串char arr[] = "abcdef"; printf("%dn", strlen(arr)); printf("%dn", strlen(arr + 0)); printf("%dn", strlen(*arr)); printf("%dn", strlen(arr[1])); printf("%dn", strlen(&arr)); printf("%dn", strlen(&arr + 1)); printf("%dn", strlen(&arr[0] + 1)); printf("%dn", sizeof(arr)); printf("%dn", sizeof(arr + 0)); printf("%dn", sizeof(*arr)); printf("%dn", sizeof(arr[1])); printf("%dn", sizeof(&arr)); printf("%dn", sizeof(&arr + 1)); printf("%dn", sizeof(&arr[0] + 1));
解析1:
#include#include int main() { char arr[] = "abcdef"; printf("%dn", strlen(arr));//字符串长度 printf("%dn", strlen(arr + 0));//从第一个元素开始数 // printf("%dn", strlen(*arr)); err // printf("%dn", strlen(arr[1])); err printf("%dn", strlen(&arr));//从第一个元素开始数 printf("%dn", strlen(&arr + 1));//从‘’后一个元素开始数 随机值 printf("%dn", strlen(&arr[0] + 1));从第二个元素开始数 return 0; }
答案 :
解析2:
#include#include int main() { char arr[] = "abcdef"; printf("%dn", sizeof(arr));//字符串+ 7 printf("%dn", sizeof(arr + 0));//首元素地址 4/8 printf("%dn", sizeof(*arr));//首元素'a' printf("%dn", sizeof(arr[1]));//元素'b' printf("%dn", sizeof(&arr));//首元素地址 4/8 printf("%dn", sizeof(&arr + 1));//''后的地址 4/8 printf("%dn", sizeof(&arr[0] + 1));//'b'地址 4/8 return 0; }
答案:
换一种写法:
char* p = "abcdef"; printf("%dn",sizeof(p)); printf("%dn",sizeof(p+1)); printf("%dn",sizeof(*p)); printf("%dn",sizeof(p[0])); printf("%dn",sizeof(&p)); printf("%dn",sizeof(&p+1)); printf("%dn",sizeof(&p[0]+1)); printf("%dn",strlen(p)); printf("%dn",strlen(p+1)); printf("%dn",strlen(*p)); printf("%dn",strlen(p[0])); printf("%dn",strlen(&p)); printf("%dn",strlen(&p+1)); printf("%dn",strlen(&p[0]+1));
解析3:
#include#include int main() { char* p = "abcdef"; printf("%dn", strlen(p));//p中存放的是'a'的地址,strlen(p)就是从'a'的位置向后求字符串的长度,长度是6 printf("%dn", strlen(p + 1));//p+1是'b'的地址,从b的位置开始求字符串长度是5 //printf("%dn", strlen(*p));//err //printf("%dn", strlen(p[0]));//err printf("%dn", strlen(&p));//随机值 printf("%dn", strlen(&p + 1));//随机值 printf("%dn", strlen(&p[0] + 1));//p[0] -> *(p+0) -> *p ->'a' ,&p[0]就是首字符的地址,&p[0]+1就是第二个字符的地址 //从第2 字符的位置向后数字符串,长度是5 printf("%dn", sizeof(p)); //p是一个指针变量,sizeof(p)计算的就是指针变量的大小,4 / 8个字节 printf("%dn", sizeof(p + 1));//p是指针变量,是存放地址的,p+1也是地址,地址大小就是4/8字节 printf("%dn", sizeof(*p));//*p访问的是1个字节 printf("%dn", sizeof(p[0]));//p[0]--> *(p+0) -> *p 1个字节 printf("%dn", sizeof(&p));//&p也是地址,是地址就是4/8字节,&p是二级指针 printf("%dn", sizeof(&p + 1)); //&p是地址, + 1后还是地址,是地址就是4 / 8字节 //&p + 1,是p的地址+1,在内存中跳过p变量后的地址 printf("%dn", sizeof(&p[0] + 1));//p[0]就是a,&p[0]就是a的地址,&p[0]+1就是b的地址,是地址就是4/8字节 return 0; }
答案见解析;
4、二维数组int a[3][4] = {0}; 1printf("%dn",sizeof(a)); 2printf("%dn",sizeof(a[0][0])); 3printf("%dn",sizeof(a[0])); 4printf("%dn",sizeof(a[0]+1)); 5printf("%dn",sizeof(*a[0]+1)); 6printf("%dn",sizeof(a+1)); 7printf("%dn",sizeof(*(a+1))); 8printf("%dn",sizeof(&a[0]+1)); 9printf("%dn",sizeof(*(&a[0]+1))); 10printf("%dn",sizeof(*a)); 11printf("%dn",sizeof(a[3]));
解析:
1.数组名单独放在sizeof内部,计算的是整个数组的大小,12*4=48
2.首元素,4
3.a[0]表示第一行的数组名 ,a[0]作为数组名单独放在sizesr内部 ,计算的是整行数组的大小 , 4 * 4 = 16
4.a[0]作为第一行的数组名,没有&,没有单独放在sizeof内部,所以a[0]表示的就是首元素的地址,即a[0][0]的地址,a[0]+1就是第一行第二个元素的地址。是地址就4/8
5.第一行第二个元素 4
6.a是二维数组的数组名,没有&,没有单独放在sizeof内部,a表示首元素的地址,即第一行的地址a+1就是第二行地址,是类型为int(*)[4]的数组指针。是地址就是4/8字节
7.*(a+1)就是第二行,相当于第二行的数组名,*(a+1) -> a[1] ,sizeof (*(a+1))计算的是第二行的大小,16字节
8.*(&a[0]+1)就相当于第二行,也就是a[1],sizeof(a[1]),大小是16字节
9.a二维数组的数组名,没有&,没有单独放在sizeof内部,a表示首元素的地址,*a就是二维数组的首元素,也就是第一行。*a- > *(a+0) -> a[0] 16
10.感觉a[3]是越界了,但是没关系 ,因为sizeof并不会访问,而会自动推导出类型为int [4] 16
进阶提升 text1:#includeint main() { int a[5] = { 1, 2, 3, 4, 5 }; int* ptr = (int*)(&a + 1); printf("%d,%d", *(a + 1), *(ptr - 1)); return 0; } //程序的结果是什么?
*(ptr - 1) :
&a表示取出整个数组的地址,&a+1就跳过整个数组,&a的类型:int(*)[5],&a+1的类型还是int(*)[5],将&a+1强制类型转换为int*,赋给ptr,则ptr指向的就是&a+1的地址,ptr-1即为前一个元素的地址,再解引用*(ptr-1)拿到的就是5。
*(a + 1):
a表示数组名为首元素1的地址,+1表示元素2的地址,再解引用*(a+1)就是2。
答案 2,5
text2:#includestruct Test { int Num; char* pcName; short sDate; char cha[2]; short sBa[4]; }*p; //假设p 的值为0x100000。 如下表表达式的值分别为多少? //已知,结构体Test类型的变量大小是20个字节 int main() { printf("%pn", p + 0x1); printf("%pn", (unsigned long)p + 0x1); printf("%pn", (unsigned int*)p + 0x1); printf("%xn", p + 0x1); printf("%xn", (unsigned long)p + 0x1); printf("%xn", (unsigned int*)p + 0x1); //%p以地址的形式打印,不省略0 //%x就是打印16进制,省略0 return 0; }
p+0x1:
整形指针(int*)+1跳过4个字节,字符指针(char*)+1跳过1个字节,结构体指针p+1应该跳过一个结构体大小,也就是20字节,20的16进制是0x000014,加完后是0x100014。
(unsigned long)p + 0x1:
p本来是个结构体指针,把p强转成unsigned long类型,就是将变成无符号整型,就不再是指针了,既然是无符号整型,那就当成一个数字,加1后就直接加就行了,即0x100001
(unsigned int*)p + 0x1:
p被强制类型转换成整型指针,整型指针+1跳过4个字节,加4即为0x100004
标准答案:
00100014
00100001
00100004
100014
100001
100004
答案:(这里没有假设p 的值为0x100000,p值为0x000000)
text3#includeint 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; }
ptr1[-1]:
&a取出的是数组的地址,&a+1跳过整个数组,将其强制类型转换为int*赋给ptr1,此时ptr1的地址就是&a+1,而ptr[-1]相当于*(ptr1-1)得到4
*ptr2:
数组名a表示首元素地址,将其强制类型转化为整型,就是一个值,加1就是加了1个字节,需要将内存化为以字节为单位的数据,元素1就是4个字节,如果是小端,假设a的地址0x10,转成10进制就是16,加1就是17,16进制为0x11,找到ptr2的地址了,再解引用就只需再往后访问4个字节即可,打印出来即为2000000
答案,4,02000000
text4#includeint main() { int a[3][2] = { (0, 1), (2, 3), (4, 5) }; int* p; p = a[0]; printf("%d", p[0]); return 0; }
解析:
看到此图,我猜你直呼卧槽并且什么都会了
此题考到了逗号表达式,int a[3][2] = { (0, 1), (2, 3), (4, 5) };可以转化为int a[3][2] = { 1, 3, 5 };此数组为3行2列,a[0]是第一行的数组名,数组名表示首元素地址,a[0]代表第一行第一个元素的地址,也就是p指向的位置,p[0] = *(p+0) = *p,p解引用拿到的就是1。
#includeint 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; }
解析:
*(ptr1 - 1):
&aa表示二维数组的地址,&aa+1表示跳过整个二维数组,强转成整型指针赋给ptr1,ptr1-1再解引用拿到的就是数字10。
*(ptr2 - 1):
aa为数组名表示二维数组首元素第一行的地址,aa+1跳过第一行来到第二行,再解引用*(aa+1)拿到第二行数组名首元素地址,即元素6的地址,强转赋给ptr2,ptr2-1向前移动再解引用拿到的就是5。
答案:
text6#includeint main() { char* a[] = { "work","at","alibaba" }; char** pa = a; pa++; printf("%sn", *pa); return 0; }
题目分析:本题难度不大,只需找到指针pa初始指向的位置以及指针变量pa++以后所指向的字符串的首地址即可,如图所示:
pa的类型是char*,加1表示跳过了一个char*的元素,指向如图所示位置,再解引用*pa拿到a的地址,再%s向后访问到停止。即为at。
text7#includeint main() { char* c[] = { "ENTER","NEW","POINT","FIRST" }; char** cp[] = { c + 3,c + 2,c + 1,c }; char*** cpp = cp; printf("%sn", **++cpp); printf("%sn", *-- * ++cpp + 3); printf("%sn", *cpp[-2] + 3); printf("%sn", cpp[-1][-1] + 1); return 0; }
**++cpp:
++cpp跳过了一个char**元素的地址到如图所示位置,解引用*++cpp拿到了c+2这个元素,c+2又是c里第3个元素的地址,再解引用拿到了p的地址,以%s的形式打印直到为止,即POINT。
*-- * ++cpp + 3:
++cpp再跳过一个char*的元素到图示位置,再解引用 * ++cpp拿到c+1,-- * ++cpp让c+1-1=c,此时c就是c数组名第一个元素地址,再解引用*-- * ++cpp拿到E的地址,再+3指向第二个E,再%s打印处ER。
*cpp[-2] + 3:
*cpp[-2]就是**(cpp-2)+3。cpp-2指向的位置如图所示,解引用*(cpp-2)拿到c+3,再解引用**(cpp-2)拿到F的地址,再+3指向S,再%s打印出ST。
cpp[-1][-1] + 1:
cpp[-1][-1] + 1就是*(*(cpp-1)-1)+1,cpp-1的位置如图,解引用拿到c+2,减1就是c+1,再解引用*(*(cpp-1)-1)拿到的就是N的地址,再加1指向E,%s打印出EW。
答案:
总结:这些道题考查了二维数组的访问、数组的存储、大端模式、小端模式、数组名与&数组名+1所代表的含义、 *** 作符结束运算后变量是否发生改变以及指针的运算,画图更加便于理解数组与指针相结合的题目,希望大家可以加深理解。
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)