题目1
//一维数组
int a[ ] = { 1,2,3,4 };
printf("%d\n", sizeof(a));? ? ? ? ? ? ? ? ? ? ? ?//sizeof(数组名)，计算的是整个数组的大小，为4×4=16
printf("%d\n", sizeof(a + 0));
//当操作数不只是数组名时，数组名代表数组首元素的地址，因此a+0同样是数组首元素的地址，地址在32位机占4个字节，在64位机占8个字节，4/8
printf("%d\n", sizeof(*a));
//a是数组首元素地址，*a是数组首元素，类型是int型，占4个字节，4
printf("%d\n", sizeof(a + 1));
//a是数组首元素地址，加1向后偏移一个int型的字节，就是数组第二个元素的地址，仍然是一个地址，因此同样占4/8个字节
printf("%d\n", sizeof(a[1]));
//a[1]也可以化为 *(a+1)，是数组第二个元素，为int型，占4个字节，4
printf("%d\n", sizeof(&a));
//&a取出的是整个数组的地址，它与数组首元素的地址是相同的，但两者意义却是不同的，但其仍为地址，同样占4/8个字节
printf("%d\n", sizeof(*&a));
//&a先取出了整个数组的地址(是int (*) [4]类型)，解引用符号访问的权限是整个数组，计算的是整个数组的大小，占16个字节
printf("%d\n", sizeof(&a + 1));
//先取出整个数组的地址，再将其加1，这里的加1其实是向后跳过了一个数组的大小，是数组尾元素的下一个地址，仍然是一个地址，占4/8个字节
printf("%d\n", sizeof(&a[0]));
//&arr[0]( 可以化为 &(*(a+0))?)，取出数组首元素的地址，占4/8个字节
printf("%d\n", sizeof(&a[0] + 1));
//&a[0]+1( 可以化为 &(*(a+0))+1)，表示数组第二个元素的地址，占4/8个字节
//字符数组
char arr[ ] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr));
//sizeof(数组名)，计算整个数组的大小，为1×6=6
printf("%d\n", sizeof(arr + 0));
//arr+0是数组首元素的地址，占4/8个字节
printf("%d\n", sizeof(*arr));
//arr表示数组首元素地址，*a是数组首元素，类型是char，占1个字节，1
printf("%d\n", sizeof(arr[1]));
//arr[1]是数组第二个元素，类型是char，占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，&arr[0] 取出数组首元素的地址，加1向后移动一个char的字节，是数组第二个元素的地址，占4/8个字节
//strlen计算字符串长度，给定一个指针，从该地址开始查找，依次向后查找1个字节，当找到'\0'时停止
printf("%d\n", strlen(arr));
//arr是数组首元素的地址，从此地址向后找'\0'，由于数组的最后一个元素不是'\0'，因此当查找尾元素后，将继续查找，直到找到'\0'，因此结果应为随机值
?printf("%d\n", strlen(arr + 0));
//arr+0仍为数组首元素的地址，如上，为随机值
printf("%d\n", strlen(*arr));//arr是数组首元素地址，*arr是数组首元素，是一个char型元素，字符‘a'，但参数想要的是一个地址，因此'a'的ASCII码值97将会被看成是一个地址，这样进行内存访问会出错 err
printf("%d\n", strlen(arr[1]));//arr[1]是数组第二个元素，'b' - 98，它表示的意义和*arr一样，同样会出错 err
printf("%d\n", strlen(&arr));//&arr取出整个数组的地址，此地址和数组首元素的地址一样，但意义不同，但在这里仍然是从此地址开始向后找'\0'，因此仍为随机值
printf("%d\n", strlen(&arr + 1));//&arr取出整个数组的地址，加1后向后跳过了一个数组的字节大小，是数组尾元素的下一个地址，从此位置向后找'\0'，在如上数组中，结果应为随机值-6
printf("%d\n", strlen(&arr[0] + 1));//&arr[0]取出数组首元素地址，加1向后移动一个char的大小，是数组第二个元素的地址，从此位置向后找'\0'，在此数组中，结果应为随机值-1
char arr[ ] = "abcdef";
printf("%d\n", sizeof(arr));//sizeof(数组名)，计算整个数组的大小，为1×7=7
printf("%d\n", sizeof(arr + 0));
//arr+0是数组首元素的地址，占4/8字节
printf("%d\n", sizeof(*arr));
//*arr是数组首元素，char型，占1字节
printf("%d\n", sizeof(arr[1]));
//arr[1]也是数组首元素，char型，占1字节
printf("%d\n", sizeof(&arr));//&arr取出的是整个数组的地址，也同样是地址，占4/8个字节
printf("%d\n", sizeof(&arr + 1));//&arr+1取出整个数组地址，加1后跳过一个数组的大小，是数组尾元素的下一个位置的地址，占4/8个字节
printf("%d\n", sizeof(&arr[0] + 1));//&arr[0]+1，取出数组首元素地址后加1，是数组第二个元素的地址，占4/8个字节
printf("%d\n", strlen(arr));//arr是数组首元素的地址，从此位置向后找'\0'，结果为6
printf("%d\n", strlen(arr + 0));//arr+0同样是数组首元素的地址，结果为6
printf("%d\n", strlen(*arr));//*arr，是数组首元素的值，为'a'，ASCII码值被看作一个地址，会出现错误 err
printf("%d\n", strlen(arr[1]));//arr[1]是数组第二个元素，为'b'，同样会出现错误 err
printf("%d\n", strlen(&arr));//&arr，取出整个数组地址，与数组首元素地址相同，从此位置向后找'\0'，结果为6
printf("%d\n", strlen(&arr + 1));//&arr+1，取出整个数组地址，加1向后跳过一个数组的大小，是数组尾元素的下一个位置的地址，从此向后找'\0'，结果为随机值
printf("%d\n", strlen(&arr[0] + 1));//&arr[0]取出数组首元素地址后加1，是数组第二个元素的地址，从此向后找'\0'，结果为5
char* p = "abcdef";
//字符指针指向常量字符串
printf("%d\n", sizeof(p));//p是一个指针变量，占4/8个字节
printf("%d\n", sizeof(p + 1));//p+1，p指向'a'，加1后向后移动一个char的大小，是'b'的地址，占4/8个字节
printf("%d\n", sizeof(*p));//*p是首元素'a'，是char型，占1个字节
printf("%d\n", sizeof(p[0]));/p[0]，同样是首元素'a'，占1个字节
printf("%d\n", sizeof(&p));//&p，是指针变量p的地址，占4/8个字节
printf("%d\n", sizeof(&p + 1));//&p+1是跳过p之后的地址，占4/8个字节
printf("%d\n", sizeof(&p[0] + 1));//&p[0]取出'a'的地址，加1是后是‘b'的地址，占4/8个字节
printf("%d\n", strlen(p));
//p是'a'的地址，向后找'\0'，结果为6
printf("%d\n", strlen(p + 1));//p+1，p指向'a'，加1后指向'b'，向后找'\0'，结果为5
printf("%d\n", strlen(*p));//*p，*p是字符'a' - 97，err
printf("%d\n", strlen(p[0]));
//p[0]，p[0]同样代表字符'a'，err
printf("%d\n", strlen(&p));//&p取出指针变量p的地址，从此向后找'\0'，结果是随机值
printf("%d\n", strlen(&p + 1));//&p+1是指针变量p的下一个地址，从此向后找'\0'，结果是随机值
printf("%d\n", strlen(&p[0] + 1));//&p[0]是‘a'的地址，加1后是'b'的地址，向后找'\0'，结果是5
//二维数组
int a[3][4] = { 0 };printf("%d\n", sizeof(a));
//sizeof(数组名)，计算的是整个数组大小，4×3×4 = 48
printf("%d\n", sizeof(a[0][0]));
//是数组第一行第一个元素，int型，4个字节
printf("%d\n", sizeof(a[0]));//arr[0]是第一行的数组名，sizeof(第一行数组名)，计算的是第一行的大小，4×4 = 16
printf("%d\n", sizeof(a[0] + 1));
//a[0]是第一行数组名，没有单独放在sizeof内，也没有被取地址，因此是数组首元素的地址，a[0]+1是数组第一行第二个元素的地址，占4/8个字节
printf("%d\n", sizeof(*(a[0] + 1)));//是数组第一行第二个元素，int型，占4个字节
printf("%d\n", sizeof(a + 1));//a是数组第一行的地址，a+1是数组第二行的地址，4/8
printf("%d\n", sizeof(*(a + 1)));//*(a+1)是对第二行地址解引用，计算的就是数组第二行的大小，4×4 = 16
printf("%d\n", sizeof(&a[0] + 1));//&a[0]取的是数组第一行的地址，加1就是数组第二行的地址，4/8
printf("%d\n", sizeof(*(&a[0] + 1)));//*(&a[0] + 1)，对第二行的地址解引用，计算的是数组第二行的大小，4×4 = 16
printf("%d\n", sizeof(*a));//a是数组第一行的地址，对它解引用是第一行，计算的是数组第一行的大小，4×4 = 16
printf("%d\n", sizeof(a[3]));//a[3]是数组第四行，虽然整个数组只有三行，但是sizeof在计算时实际上是根据数据类型计算的，而这个数组一行的类型是int [4]，因此所占字节为4×4 = 16
注：下述题目都以32位机来进行解答
题目二
#include<stdio.h>
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int* ptr = (int*)(&a + 1);
printf("%d,%d", *(a + 1), *(ptr - 1));
return 0;
}
题目三
#include<stdio.h>
struct Test
{
int Num;
char* pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
int main()
{
p = (struct Test*)0x100000;
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}32位机下 此结构体大小为20个字节
64位机下 此结构体大小为32个字节
p+0x1，此时p是struct Test*型，在32位机下，加1向后偏移20个字节，00100014；在64位机下，加1向后偏移20个字节，0000000000100020
(unsigned long)p+0x1，p被强制类型转换为无符号长整形，加1就是整型加1，32位机，00100001；64位机，0000000000100001
(unsigned int*))p+0x1，p被强制转换为unsigned int*型，加1向后偏移4个字节，32位机，00100004；64位机，0000000000100004
注：结构体大小对于不同环境下可能不同，运行结果可能出现差异
题目四
#include<stdio.h>
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
注：此代码结果在32位机可得，64位机指针变量比整型变量大，无法得到此答案
题目五
#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;
}逗号表达式，这个数组实际上存储的值为 1，3，5，0，0，0
p是数组第一行首元素的地址，p[0]可化为*(p+0)是第一行首元素，输出1
题目六
#include<stdio.h>
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;
}
指针-指针 = 它们之间的元素个数，因此为 -4
以%p打印，认为内存中存放的是地址
-4的补码为 11111111 11111111 11111111 11111100
输出为 FF FF FF FC
题目七
#include<stdio.h>
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;
}
题目八
#include<stdio.h>
int main()
{
char* a[] = { "work","at","home" };
char** pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}
题目九
#include<stdio.h>
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;
}
1.cpp最初指向数组cp首元素地址，＋+后指向数组qp第一个元素的地址，解引用后是数组cp第一个元素，此元素是char**型。存放着数组c第二个元素的地址，解引用后是数组c第二个元素，此元素是char*型，存放常量字符串"POINT"首字符地址，从此地址向后打印字符串,输出POINT
2.cpp现在指向的是数组cp第一个元素的地址，再次++指向输出cp第二个元素的地址，解引用后是数组cp第二个元素，是char**型，存放数组c第一个元素的地址，--后是数组c首元素的地址，解引用后是数组c首元素，是char*型，存放常量字符串"ENTER"首字符地址，+3向后跳过3个char字节大小，指向字符'e'，此从地址向后打印字符串，输出ER
3.cpp[-2]可以化为*(cpp-2)，cpp现在指向数组cp第二个元素的地址，-2后是数组cp首元素的地址，解引用后是数组cp首元素，存放的是数组c第三个元素的地址，解引用后是数组c的第三个元素，此元素存放常量字符串"FIRST"首字符地址，+3向后跳过3个char字节大小，指向字符's'，从此地址向后打印字符串，输出ST
4.cpp[-1][1]可以化为*(cpp[-1]-1).再化为*(*(cpp-1)-1),cpp指向数组cp第二个元素的地址，-1后指向数组cp第一个元素的地址，解引用后是数组cp第一个元素，此元素存放数组c第二个元素的地址，-1后是数组c第一个元素的地址，解引用后是数组c第一个元素，最后+1向后跳过1个char字节大小，指向'E'，从此地址向后打印字符串，输出EW
