sizeof相关的习题

1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。

(放地址情况都视为sizeof（指针），4/8) 2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。 3. 除此之外所有的数组名都表示首元素的地址。

1.一维数组

    int arr[] = { 1,2,3,4 };//4*4=16
    printf("%d\n", sizeof(arr));//16
    printf("%d\n", sizeof(arr + 0));//a+0 其实是数组第一个元素的地址，是地址就是4/8字节
    printf("%d\n", sizeof(*arr));//*a是数组首元素，计算的是数组首元素的大小，单位是字节，4
    printf("%d\n", sizeof(arr + 1));//a+1是第二个元素的地址，是地址大小就是4/8
    printf("%d\n", sizeof(arr[1]));//a[1]是第二个元素，计算的是第二个元素的大小-4-单位是字节
    printf("%d\n", sizeof(&arr));//&a是整个数组的地址，整个数组的地址也是地址，地址的大小就是4/8字节
    //&a---> 类型：int(*)[4]

    printf("%d\n", sizeof(*&arr));//&a是数组的地址，*&a就是拿到了数组，计算的是整个数组的大小，单位是字节-大小是16
    printf("%d\n", sizeof(&a + 1));//&a是整个数组的地址，&a+1，跳过整个数组，指向数组后边的空间，是一个地址，大小是4/8字节
    printf("%d\n", sizeof(&a[0]));//&a[0]是首元素的地址，计算的是首元素地址的大小，4/8字节
    printf("%d\n", sizeof(&a[0] + 1));//&a[0] + 1是第二个元素的地址，地址的大小就是4/8字节
    return 0;

2.字符数组

    char arr[] = { 'a','b','c','d','e','f' };
    //char*
    //char [6]
    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]));//'b'-98,和上面的代码类似，是非法访问 - err
    printf("%d\n", strlen(&arr));//&arr虽然是数组的地址，但是也是从数组起始位置开始的，计算的还是随机值
    //char(*)[6]
    printf("%d\n", strlen(&arr + 1));
    //&arr是数组的地址，&arr+1是跳过整个数组的地址，求字符串长度也是随机值
    printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址，是'b'的地址，求字符串长度也是随机值

    //printf("%d\n", sizeof(arr));//arr单独放在sizeof内部，计算的是整个数组的大小，单位是字节，6
    //printf("%d\n", sizeof(arr + 0));//arr + 0是数组首元素的地址，4/8
    //printf("%d\n", sizeof(*arr));//*arr是数组的首元素，计算的是首元素的大小-1字节
    //printf("%d\n", sizeof(arr[1]));//arr[1]是第二个元素，大小1字节
    //printf("%d\n", sizeof(&arr));//取出的数组的地址，数组的地址也是地址，是地址大小就是4/8
    //printf("%d\n", sizeof(&arr + 1));//&arr+1是跳过整个，指向数组后边空间的地址，4/8
    //printf("%d\n", sizeof(&arr[0] + 1));//&arr[0] + 1是数组第二个元素，大小是一个字节

printf("%d\n", sizeof(*arr));//*arr是数组的首元素，计算的是首元素的大小-1字节

（*arr可以看成*（arr+1））

printf("%d\n", sizeof(arr + 0));//arr + 0是数组首元素的地址，4/8

（此处数组名并非单独放在sizeof内部）

3.字符串

    char arr[] = "abcdef";//数组是7个元素
    //[a b c d e f \0]
    printf("%d\n", strlen(arr));//6,arr是数组首元素的地址，strlen从首元素的地址开始统计\0之前出现的字符个数，是6
    printf("%d\n", strlen(arr + 0));//arr + 0是数组首元素的地址，同第一个，结果是6
    //printf("%d\n", strlen(*arr));//*arr是'a',是97，传给strlen是一个非法的地址，造成非法访问
    //printf("%d\n", strlen(arr[1]));//err
    printf("%d\n", strlen(&arr));//6
    printf("%d\n", strlen(&arr + 1));//&arr + 1是跳过数组后的地址，统计字符串的长度是随机值
    printf("%d\n", strlen(&arr[0] + 1));//&arr[0]+1是b的地址，从第二个字符往后统计字符串的长度，大小是5

    printf("%d\n", sizeof(arr));//7 - 数组名单独放在sizeof内部，计算的是数组的总大小，单位是字节
    printf("%d\n", sizeof(arr + 0));//arr+0是首元素的地址，大小是4/8
    printf("%d\n", sizeof(*arr));//*arr是数组首元素，大小是1字节
    printf("%d\n", sizeof(arr[1]));//arr[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是第二个元素的地址，是4/8字节

    return 0;

printf("%d\n", strlen(*arr));//*arr是'a',是97，传给strlen是一个非法的地址，造成非法访问

4.常量字符串

    const char* p = "abcdef";
    printf("%d\n", strlen(p));//6- 求字符串长度
    printf("%d\n", strlen(p + 1));//p + 1是b的地址，求字符串长度就是5
    //printf("%d\n", strlen(*p));//err，*p是'a'
    //printf("%d\n", strlen(p[0]));//err - 同上一个
    printf("%d\n", strlen(&p));//&p拿到的是p这个指针变量的起始地址，从这里开始求字符串长度完全是随机值
    printf("%d\n", strlen(&p + 1));//&p+1是跳过p变量的地址，从这里开始求字符串长度也是随机值
    printf("%d\n", strlen(&p[0] + 1));//&p[0] + 1是b的地址，从b的地址向后数字符串的长度是5

    //printf("%d\n", sizeof(p));//p是指针变量，大小就是4/8字节
    //printf("%d\n", sizeof(p + 1));//p + 1是b的地址，是地址，就是4/8个字节
    //printf("%d\n", sizeof(*p));//*p是'a'，sizeof(*p)计算的是字符的大小，是1字节
    //printf("%d\n", sizeof(p[0]));//p[0]-->*(p+0) --> *p  就同上一个，1字节
    //printf("%d\n", sizeof(&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’,&p[0]就是a的地址，+1，就是b的地址，是地址就是4/8

    return 0;

printf("%d\n", sizeof(&p[0] + 1));//p[0]就是‘a’,&p[0]就是a的地址，+1，就是b的地址，是地址就是4/8

（注意此处并不是访问，所以不构成非法访问）

printf("%d\n", sizeof(&p)); //&p是二级指针，是指针大小就是4/8

5.二维数组

//二维数组
    int a[3][4] = { 0 };
    //printf("%p\n", &a[0][0]);
    //printf("%p\n", a[0]+1);


    printf("%d\n", sizeof(a));//48 = 3*4*4
    printf("%d\n", sizeof(a[0][0]));//4
    printf("%d\n", sizeof(a[0]));//a[0]是第一行的数组名，数组名单独放在sizeof内部，计算的就是数组(第一行)的大小，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)));//*(a[0] + 1)是第一行第2个元素，计算的是元素的大小-4个字节
    printf("%d\n", sizeof(a + 1));//a是二维数组的数组名，数组名表示首元素的地址，就是第一行的地址，a+1就是第二行的地址
    //第二行的地址也是地址，是地址就是4/8   
    //a - int (*)[4]
    //a+1--> int(*)[4]
    printf("%d\n", sizeof(*(a + 1)));//a+1是第二行的地址，*(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) 是对第二行的地址解引用，得到的就是第二行，计算的就是第二行的大小
    printf("%d\n", sizeof(*a));//a表示首元素的地址，就是第一行的地址，*a就是第一行，计算的就是第一行的大小
    //*a -- *(a+0)--a[0]
    printf("%d\n", sizeof(a[3]));//16字节 int[4]
    //如果数组存在第四行，a[3]就是第四行的数组名，数组名单独放在sizeof内部，计算的是第四行的大小

    int a = 10;
    printf("%d\n", sizeof(int));

    return 0;

printf("%d\n", sizeof(*a));//a表示首元素的地址，就是第一行的地址，*a就是第一行，计算的就是第一行的大小

6.几条习题

第一题

第二题

    struct Test
{
    int Num;
    char* pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}* p;
假设p 的值为0x100000。 如下表表达式的值分别为多少？
已知，结构体Test类型的变量大小是20个字节
int main()
{
    p = (struct Test*)0x100000;
    printf("%p\n", p + 0x1);
    //0x00100014//结构体指针加一，跳过一个结构体的大小
    printf("%p\n", (unsigned long)p + 0x1);
    //0x00100001//强制转换成无符号整形，正常加一
    printf("%p\n", (unsigned int*)p + 0x1);
    //0x00100004//强制转换成unsigned int型指针加一
    return 0;

第三题

    int a[4] = { 1, 2, 3, 4 };
    int* ptr1 = (int*)(&a + 1);
    int* ptr2 = (int*)((int)a + 1);//把a首元素地址强制转化成整形后再加1，此时指向的是1这个元素的第二个字节
    printf("%x,%x", ptr1[-1], *ptr2);
    return 0;
    //01 00 00 00  //02 00 00 00  //03 00 00 00  // 04 00 00 00
    //所以答案是00 00 00 04,02 00 00 00

第四题

    int a[3][2] = { (0, 1), (2, 3), (4, 5) };//注意此处的逗号表达式
    //1 3
    //5 0
    //0 0
    int* p;
    p =(int *) a[0];//a[0]的类型是int （*）[2]
    printf("%d", p[0]);
    return 0;

第六题

    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个，所以%d打印-4

但是%p打印的是计算机存储的-4补码，

-4的原码

1000...0100（原码）

1111...1011（反码）

1111...1100（补码）

转换成十六进制就是

ff ff ff fc