• C语言----深入理解指针（5）

    1.sizeof和strlen的对比

    sizeof计算变量所占内存空间的大小的，单位是字节

    sizeof只关注内存空间的大小，不在乎内存中方的什么数据

    sizeof是操作符不是函数

    sizeof会将\0算进去的

    1. // sizeof计算变量所占内存空间的大小的，单位是字节
    2.  
    3. int main()
    4. {
    5.     int a = 10;
    6.     printf("%d\n", sizeof(int));//输出结果是4
    7.     printf("%d\n", sizeof(a));//输出结果是4
    8.  
    9.  
    10.     int arr[10] = { 0 };
    11.     printf("%d\n", sizeof(arr));//输出的结果是40
    12.     return 0;
    13. }//sizeof只管新占了多大的内存空间大小

    那么strlen呢？

    strlen是c语言里面的库函数，是函数

    作用的求字符串长度的，只能针对字符串

    strlen统计的是字符串\0之前的字符个数

    只能指针字符串，求字符串长度

    不能求整形数组的

    strlen直到遇到\0,不然是不会停下来的

    1. int main()
    2. {
    3.     char arr1[] = { 'a','b','c' };
    4.     char arr2[] = "abc";//字符串末尾隐藏着一个\0
    5.     printf("%zd\n", strlen(arr1));//15---往后找\0,直到找到\0才停止--那么这个15就是随机值
    6.     printf("%zd\n", strlen(arr2));//3---\0前面有三个字符
    7.  
    8.  
    9.     printf("%zd\n", sizeof(arr1));//3---只关乎arr1占了多大的空间
    10.     printf("%zd\n", sizeof(arr2));//4---放了4个字符，包括\0，总共占了4个字节 
    11.  
    12.  
    13.     //strlen是用来求字符串长度的，不能用来求整型数组
    14.  
    15.     return 0;
    16. }

    2.数组和指针笔试题解析

    sizeof---一维数组

    1. //恢复：数组名是数组首元素的地址
    2. //但是有两个例外
    3. //sizeof(数组名)
    4. //&数组名
    5. //除了这两种，其他的都是数组首元素的地址
    6. int main()
    7. {
    8.     int a[] = { 1,2,3,4 };
    9.     printf("%zd\n", sizeof(a));//16---4个元素，每个元素4个字节
    10.     //数组名a单独放在sizeof内部，a表示的是整个数组，计算的是整个数组的大小，单位是字节
    11.  
    12.  
    13.  
    14.     printf("%zd\n", sizeof(a+0));//4
    15.     //a是数组名，数组首元素的地址，a+0还是首元素的地址
    16.     //a+i就是数组内下标为i的数组元素
    17.     //这里的sizeof计算的是首元素地址的大小
    18.  
    19.     printf("%zd\n", sizeof(*a));//4
    20.     //这里的a依然是首元素的地址，*a就是首元素，就是a[0]
    21.     //因为arr[0]是一个整数，就是4个字节
    22.  
    23.  
    24.     printf("%zd\n", sizeof(a+1));//4
    25.     //因为数组名表示的是首元素的地址，那么首元素加1
    26.     //就是下标为1的数字的地址，就是这个数组内第二个元素的地址
    27.     //arr[1]的地址
    28.     //这里计算的是地址的大小
    29.  
    30.  
    31.  
    32.     printf("%zd\n", sizeof(a[1]));//4
    33.     //a[1]就是数组内第二个元素，就是4个字节的大小
    34.  
    35.  
    36.  
    37.     printf("%zd\n", sizeof(&a));//4
    38.     //取出整个数组的地址
    39.     //数组的地址也是一个地址啊，是地址就是4个字节的长度
    40.  
    41.  
    42.     printf("%zd\n", sizeof(*&a));//16
    43.     //取出a的地址，再进行解引用，就是整个数组，
    44.     //*和&抵消了，就是整个数组
    45.     // sizeof(*&a)==sizeof(a)
    46.     //&a是数组的地址，类型是int(*)[4]---数组指针类型
    47.     //那么*&a就是访问真个数组
    48.  
    49.  
    50.  
    51.     printf("%zd\n", sizeof(&a+1));//4
    52.     //&a就是整个数组的地址，地址+1就是跳过整个数组后的那个地址，
    53.     // 但是仍然是地址啊
    54.     //是地址就是4个字节
    55.  
    56.  
    57.  
    58.     printf("%zd\n", sizeof(&a[0]));//4
    59.     //arr[0]是数组首元素的地址，再将其取出
    60.     //取出数组首元素的地址
    61.  
    62.  
    63.  
    64.  
    65.     printf("%zd\n", sizeof(&a[0]+1));//4
    66.     //将首元素的地址取出，再+1就是第二个元素的地址
    67.  
    68.  
    69.     return 0;
    70. }

     sizeof--字符数组

    1. int main()
    2. {
    3.     char arr[] = { 'a','b','c','d','e','f' };//没有\0
    4.     printf("%d\n", sizeof(arr));//6
    5.     //整个数组的大小，6个字符就是6
    6.  
    7.     printf("%d\n", sizeof(arr+0));//4
    8.     //arr是首元素的地址，arr+0还是首元素的地址，地址的字节就是4
    9.  
    10.  
    11.     printf("%d\n", sizeof(*arr));//1
    12.     //对数组首元素地址进行解引用就是数组首元素，字符就是1个字节
    13.     printf("%d\n", sizeof(arr[1]));//1
    14.     //数组中下标为1的字符，大小是1个字节
    15.  
    16.  
    17.  
    18.     printf("%d\n", sizeof(&arr));//4
    19.     //取出整个数组的地址，仍然是地址，地址就是4个字节的大小
    20.  
    21.  
    22.     printf("%d\n", sizeof(&arr+1));//4
    23.     //取出整个数组的地址，+1跳过整个数组，还是地址，就是4个字节的大小
    24.  
    25.     printf("%d\n", sizeof(&arr[0]+1));//4
    26.     //取出数组首元素的地址，再+1就是第二个元素的地址，地址是4个字节大小
    27.  
    28.  
    29.     return 0;
    30. }

     strlen---大括号--一堆字符

    1. int main()
    2. {
    3.     char arr[] = { 'a','b','c','d','e','f' };//没有\0
    4.     printf("%zd\n", strlen(arr));//随机值
    5.     //这里的arr表示的是首元素的地址
    6.     //从首元素开始数字符，一直数到\0之前才停止
    7.     //那么这里的值就是随机值
    8.  
    9.     printf("%zd\n", strlen(arr+0));
    10.     //arr+0还是数组名-----首元素的地址
    11.     //那么返回的值就是随机值，这个代码和上面的代码没有区别
    12.     //并且这两个随机值是一样的
    13.  
    14.  
    15.     printf("%zd\n", strlen(*arr));
    16.     //arr是首元素的地址，那么对其进行解引用就是数组第一个元素，就是'a'字符
    17.     //strlen(a)---'a'的ASCII的大小是97，strlen不能运行
    18.     //a的值传递给strlen，strlen会认为97是地址，然后会访问内存
    19.     //这个代码是有问题的
    20.  
    21.  
    22.     printf("%zd\n", strlen(arr[1]));
    23.     //arr[1]是数组下标为1的元素
    24.     //strlen('b')---'b'的ASCII大小是98
    25.     //这个程序也会崩溃
    26.  
    27.     printf("%zd\n", strlen(&arr));//随机值
    28.     //将数组的整个数组的地址传过去了
    29.     //strlen依然从首元素往后数
    30.     //依然没有遇到\0
    31.     //那么返回值就是随机值
    32.  
    33.     //&arr的类型是----char(*)[6]
    34.  
    35.     printf("%zd\n", strlen(&arr+1));//随机值
    36.     //取出整个数字的地址，然后+1跳过整个数组
    37.     //也是随机值，不知道什么时候遇到\0
    38.  
    39.  
    40.  
    41.     printf("%zd\n", strlen(&arr[0]+1));//随机值
    42.     //arr[0]是数组首元素，+1就是b，那么strlen往后直到遇到\0才停止，那么
    43.     //这个代码返回的也是随机值
    44.  
    45.  
    46.  
    47.  
    48.     return 0;
    49. }

     sizeof--字符串

    1. //数组名是数组首元素的地址
    2. //两个例外：
    3. //sizeof(arr)
    4. //&arr---这里的数组名表示整个数组，取出的是数组的地址
    5.  
    6. int main()
    7. {
    8.     char arr[] = "abcdef";//字符串初始化
    9.     //这个字符串末尾还有一个\0
    10.     printf("%zd\n", sizeof(arr));//7
    11.     //arr作为数组名，这里计算的是这个数组的大小
    12.     //一个字符一个字节，那么这里就是7个字节
    13.     //这里的数组名是单独的放在sizeof里面的
    14.  
    15.  
    16.     printf("%zd\n", sizeof(arr + 0));//4
    17.     //数组名--就是数组首元素的地址
    18.     //这里的arr并不是单独的放在sizeof里面
    19.     //那么这里的arr+0是首元素的地址
    20.     //既然是地址，那么大小就是4个字节
    21.  
    22.  
    23.  
    24.     printf("%zd\n", sizeof(*arr));//1
    25.     //这里的arr是数组名--首元素的地址
    26.     //对arr进行解引用达到的就是首元素
    27.     //首元素的大小是1个字节--每个字符的大小是1个字节
    28.  
    29.  
    30.  
    31.     printf("%zd\n", sizeof(arr[1]));//1
    32.     //数组下标为1的元素，字符，所以大小也是1
    33.  
    34.  
    35.     printf("%zd\n", sizeof(&arr));//4
    36.     //取出整个数组的地址，地址就是4个字节
    37.  
    38.  
    39.  
    40.     printf("%zd\n", sizeof(&arr + 1));//4
    41.     //取出的是整个数组的地址，再+1，得到的就是跳过整个数组
    42.     //得到的也是地址，既然是地址就是4个字节的大小
    43.  
    44.  
    45.  
    46.  
    47.     printf("%zd\n", sizeof(&arr[0] + 1));//4
    48.     //arr[0]是数组首元素，取出数组首元素的地址再+1
    49.     //得到的就是数组内的第二元素的地址，地址就是4个字节大小
    50.     //首元素的地址类型是char*
    51.  
    52.  
    53.     return 0;
    54. }

     strlen---字符串

    1. int main()
    2. {
    3.     char arr[] = "abcdef";//字符串末尾放着\0的
    4.     printf("%d\n", strlen(arr));//6
    5.     //这里的arr是首元素的地址
    6.     // 从首元素开始数，数到\0之前就停止
    7.     //strlen是求字符串长度的
    8.     //因为末尾放着一个\0，那么strlen数的就是\0前面的字符个数
    9.     //strlen是从第一个元素开始统计\0之前的字符个数
    10.  
    11.  
    12.     printf("%d\n", strlen(arr + 0));//6
    13.     //arr是首元素的地址，那么arr+0还是首元素的地址
    14.     //那么把数组首元素的地址传给strlen，就是从首元素开始统计，直到遇到\0
    15.  
    16.  
    17.  
    18.     printf("%d\n", strlen(*arr));
    19.     //arr是首元素的地址，那么解引用得到的就是首元素字符'a'
    20.     //'a'的大小是97，将97当成地址传递给strlen，97这个地址不能被访问，这个程序就崩溃了
    21.  
    22.  
    23.  
    24.     printf("%d\n", strlen(arr[1]));
    25.     //arr[1]是数组下标为1的元素，第二个元素，访问的是'b'
    26.     //这个代码的道理和上面的一样，一样会崩溃的
    27.  
    28.  
    29.     printf("%d\n", strlen(&arr));//6
    30.     //取出数组的地址，将取出的地址存放至数组指针变量里面这么写
    31.     //char(*pa)[7]=&arr
    32. //那么pa的类型是char(*)[7]
    33.     //但是对于strlen这个库函数来说
    34.     //size_t strlen (const char* str)
    35.     //硬要将char(*)[7]这个地址传过去，因为char(*)[7]与const char* str不一致，会导致将传过来的指向强制转换为strlen所需要的类型
    36.     //
    37.     //数组的地址和数组首元素的地址是指向同一个位置的
    38.     //那么strlen也是从第一个元素的位置开始向后访问
    39.     //所以这个代码实现的数据是6
    40.  
    41.     printf("%d\n", strlen(&arr + 1));//随机值
    42.      //取出数组的地址，再+1就是跳过整个数组，那么strlen遇到\0才会停止
    43.     //那么这里的就是随机值
    44.  
    45.  
    46.     printf("%d\n", strlen(&arr[0] + 1));//5
    47.     //取出的是首元素的地址，那么首元素的地址+1就是数组第二个元素的地址
    48.     //那么strlen就从第二个元素开始访问进行统计的
    49.     //那么这里的 数据就是5
    50.     return 0;
    51. }
    52. //在这些代码运行的时候
    53. //会出现很多警告
    54. //因为我们在传参的时候类型不一致
    55. //&arr的类型是char(*)[7]，而strlen只能接受const char* str这个类型的指针

     sizeof---指针

    1. int main()
    2. {
    3.     char* p = "abcdef";//将首字符的地址存放在p中
    4.     printf("%zd\n", sizeof(p));//4
    5.     //p是指针变量。那么sizeof(p)计算的就是指针变量p的大小
    6.     //因为一个指针变量的大小是4个字节--x86的情况下，x64的情况下是8个字节
    7.  
    8.  
    9.  
    10.     printf("%zd\n", sizeof(p + 1));//4
    11.     //p存的是首元素的地址，p的类型是char*
    12.     //那么p+1得到的是b的地址，就是相当于跳过了一个字符
    13.     //地址的大小就是4个字节
    14.  
    15.  
    16.  
    17.     printf("%zd\n", sizeof(*p));//1
    18.     //p是字符串首元素的地址，对p进行解引用，得到的就是首元素，首元素是字符a
    19.     //a的字节大小是1
    20.     //因为p的类型是char*，只能访问一个字节，就是a
    21.  
    22.  
    23.  
    24.  
    25.     printf("%zd\n", sizeof(p[0]));//1
    26.     //p[0]-->*(p+0)---得到的就是字符a---大小为1个字节
    27.  
    28.  
    29.  
    30.     printf("%zd\n", sizeof(&p));//4
    31.     //取出p的地址，&p是p的地址，对p的地址进行大小计算，地址的大小就是4个字节
    32.  
    33.  
    34.  
    35.     printf("%zd\n", sizeof(&p + 1));//4
    36.     //取出p的地址进行+1操作
    37.     // 
    38.     // 
    39.     // char* *ptr=&p       ptr指向的p是一个类型为char*类型的指针，后面的*说明ptr是一个指针
    40.     //&p的指针类型是char * *,对&p+1就是跳过一个char* * 类型的对象
    41.  
    42.  
    43.     //举例：int *p   对p+1跳过的就是一个整型对象
    44.  
    45.  
    46.     //&p是p的地址，&p+1是跳过了p变量，指向了p的后面
    47.     //因为&p+1是地址，就是4个字节
    48.  
    49.     printf("%zd\n", sizeof(&p[0] + 1));//4
    50.     //p[0]是*（p+0）---就是首元素a
    51.     //前面加上&得到的就是a的地址，+1就是b的地址
    52.  
    53.     //&p[0]就是p
    54.  
    55.  
    56.  
    57.  
    58.     return 0;
    59. }

     strlen---指针

    1. int main()
    2. {
    3.     char* p = "abcdef";//将这个字符串首元素的地址存储在p中,末尾有\0
    4.  
    5.  
    6.     printf("%zd\n", strlen(p));//6
    7.     //p里面放的是a的地址，
    8.     //strlen(p)就是从a的地址开始统计这个字符串的长度
    9.     //得到的数据是6
    10.  
    11.  
    12.     printf("%zd\n", strlen(p + 1));//5
    13.     //p存的是a的地址，因为p是char*的指针，那么p+1就是指向b的地址
    14.     //就是从b的地址位置开始统计这个字符串的个数
    15.     //那么得到的数据就是5
    16.  
    17.  
    18.  
    19.     printf("%zd\n", strlen(*p));//程序崩溃
    20.     //*p是a，a是97
    21.     //将97作为地址传给strlen,程序会崩溃的
    22.  
    23.  
    24.     printf("%zd\n", strlen(p[0]));//程序崩溃
    25.     //p[0]--->*(p+0)----*p---a----97
    26.     //那么这个程序就会崩溃的
    27.  
    28.  
    29.     printf("%zd\n", strlen(&p));//随机值
    30.     //取出指针变量p的地址，那么strlen就从指针变量p地址开始统计，在p这块空间进行统计
    31.     //那么得到的就是随机值
    32.  
    33.  
    34.  
    35.  
    36.     printf("%zd\n", strlen(&p + 1));//随机值
    37.     //&p是指针p的地址，+1就是跳过p的地址，开始进行统计
    38.     //所以数据就是随机值
    39.  
    40.  
    41.     printf("%zd\n", strlen(&p[0] + 1));//5
    42.     //p[0]--->*(p+0)----*p---a
    43.     //那么&p[0]就相当于p,
    44.     //p里面存的是a的地址，+1得到的是b的地址
    45.     //那么我们就从b的位置开始统计
    46.     //得到的数据是5
    47.  
    48.  
    49.  
    50.     return 0;
    51. }
    52. //注意：p[0]--->*(p+0)----*p---a

     sizeof---二维数组

    1. //二维数组
    2. int main()
    3. {
    4.     int a[3][4] = { 0 };//3行4列----每一行都输一维数组
    5.     //第一行的数组名叫arr[0]---每个元素的访问a[0][i]
    6.     //第一行的数组名叫arr[1]---每个元素的访问a[1][i]
    7.     //第一行的数组名叫arr[2]---每个元素的访问a[2][i]
    8.  
    9.  
    10.  
    11.     printf("%d\n", sizeof(a));//48
    12.     //a是二维数组的数组名，单独放在sizeof内部，a表示的是整个数组，计算的就是整个数组的大小，单位是字节
    13.     //12个元素，每个元素4个字节，总共就是48个字节大小
    14.  
    15.  
    16.  
    17.     printf("%d\n", sizeof(a[0][0]));//4
    18.     //a[0][0]就是第一行第一个元素，大小是4个字节
    19.  
    20.     printf("%d\n", sizeof(a[0]));//16
    21.     //a[0]是这个二维数组的第一行的数组名
    22.     //第一行的数组名单独放在sizeof内部，计算的就是整个一维数组的大小，就是4*4=16个字节的大小
    23.  
    24.  
    25.  
    26.     printf("%d\n", sizeof(a[0] + 1));//4
    27.     //a[0]是第一行的数组名,但是没有单独放在sizeof里面，就说明这里的a[0]是第一行首元素的地址，那么首元素地址+1就是第一行第二个元素的地址
    28.     //就是a[0][0]的地址
    29.     //那么a[0] + 1--->&arr[0][0]+1--->&a[0][1]
    30.  
    31.     //因为这里是地址，那么就是4个字节大小
    32.  
    33.  
    34.  
    35.     printf("%d\n", sizeof(*(a[0] + 1)));4
    36.     //上面说a[0]+1得到的是第一行第二个元素的地址
    37.     //那么我们解引用得到的就是第一行第二个元素，是一个整型，大小是4个字节
    38.  
    39.  
    40.  
    41.     printf("%d\n", sizeof(a + 1));//4
    42.     //a + 1
    43.     //a是二维数组的数组名，并且没有单独放在sizeof内
    44.     //说明这个a是这个二维数组的首元素地址
    45.     //就是第一行的地址，那么a+1就是第二行的地址
    46.     //因为a+1是第二行的地址，传给sizeof，因为是地址，所以大小是4个字节
    47.  
    48.     //
    49.  
    50.  
    51.     printf("%d\n", sizeof(*(a + 1)));//16
    52.     //*(a+1)--->a[1]--第二行的数组名，单独放在sizeof内部，那么sizeof计算的就是第二行的大小
    53.  
    54.     //因为a+1得到的是第二行的地址，那么对其进行解引用，得到的就是第二行整个数组
    55.     //a+1是第二行的地址，类型是int(*)[4],数组指针，基因用访问的是这个数组，大小是16个字节
    56.  
    57.  
    58.     printf("%d\n", sizeof(&a[0] + 1));//4
    59.     //a[0]是第一行的数组名，&数组名就是第一行的地址，&a[0]就是取出了第一行的地址
    60.     //那么&a[0] + 1得到的就是第二行的地址
    61.     //因为是地址，那么大小就是4个字节
    62.  
    63.  
    64.     printf("%d\n", sizeof(*(&a[0] + 1)));//16
    65.     //上面说到&a[0] + 1得到的是第二行的地址，那么对第二行的地址进行解引用得到的就是第二行数组
    66.     //
    67.  
    68.  
    69.  
    70.     printf("%d\n", sizeof(*a));//16
    71.     //a作为数组名没有单独放在sizeof内，那么a就不是整个数组
    72.     //a就是这个二维数组的首元素的地址
    73.     //对其进行解引用得到的就是第一行整个数组
    74.     //4*4=16
    75.     //*a-->*(a+0)-->a[0]
    76.  
    77.  
    78.     printf("%d\n", sizeof(a[3]));//16
    79.     //这里是否越界
    80.     //sizeof内部的表达式是不会真实计算的,也不会真实去访问的
    81.     // 仅仅只是根据类型来推断长度的
    82.     //a[3]是第四行的数组名---那么计算的是第四行的大小
    83.     //第四行的类型是int[4]
    84.  
    85.  
    86.  
    87.  
    88.     return 0;
    89. }
    90.  
    91. //数组名在sizeof内单独使用，表示的就是整个数组
    92. //如果不是单独使用，我们就要考虑一下这个数组名是数组首元素的地址
    93.  
    94. //sizeof内部的表达式是不会进行运算的
    95.  
    96. int main()
    97. {
    98.     short s = 8;//short类型的数据是2个字节
    99.     int n = 12;//4个字节
    100.     printf("%zd\n", sizeof(s = n + 5));//2
    101.     //sizeof内部的表达式并没有进行运算
    102.     //sizeof(s = n + 5)这个表达式 最终结果取决于s
    103.  
    104.     printf("%zd\n", s);//8
    105.     return 0;
    106. }

    数组名的意义：

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

    2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址

    3.除此之外所有的数组名都表示数组首元素的地址

    3.指针运算笔试题解析

    题目一

    1. #include <stdio.h>
    2. int main()
    3. {
    4.     int a[5] = { 1, 2, 3, 4, 5 };
    5.     int* ptr = (int*)(&a + 1);
    6.     //&a是取出真个数组的地址，那么&a+1就是跳过了整个数组，指向的是这个数组的末尾的位置
    7.     //&a+1的地址类型是数组类型的地址int(*)[5]
    8.     //将这个地址强制类型转换为int*类型的
    9.     //准换位int*类型的地址再赋值给ptr，那么ptr指向的也是这个数组的末尾位置
    10.  
    11.  
    12.  
    13.  
    14.     printf("%d,%d", *(a + 1), *(ptr - 1));
    15.     //这里的a是数组名--数组首元素的地址，那么a+1得到的就是第二个元素的地址，就是2的地址
    16.     //解引用得到的就是2
    17.  
    18.  
    19.  
    20.     //因为ptr现在是整型指针，那么-1就是往回退，那么指向的就是5的位置
    21.     //*(ptr - 1)得到的就是5
    22.     return 0;
    23. }
    24. //&a+1就是取出整个数组再跳过这个数组，就是那么这个&a+1指向的就是这个数组的末尾
    25. //再将这个强制类型转换为int *类型的地址，再赋值给ptr
    26. //那么ptr也是指向这个数组的末尾的位置
    27. //因为ptr的类型是int *，-1就是往后退一个整型的距离，那么就是指向的5的位置

    题目二 

    1. //在X86环境下
    2. //假设结构体的⼤⼩是20个字节
    3. //程序输出的结果是啥？
    4. struct Test
    5. {                            
    6.     int Num;
    7.     char* pcName;
    8.     short sDate;
    9.     char cha[2];
    10.     short sBa[4];
    11. }*p = (struct Test*)0x100000;
    12. //在这里括号前面的是结构体，加上*就是结构体指针类型，创建变量p
    13. //先将0x100000强制转换为结构体指针，再为b进行赋值，现在p里面放的就是0x100000这个地址
    14.  
    15.  
    16.  
    17. int main()
    18. {
    19.     printf("%p\n", p + 0x1);//00100014
    20.     //指针+1和类型有关系
    21.     //整数+1就是+1
    22.  
    23.     //0x1是16进制的1
    24.     //因为p是一个结构体指针，因为前面说了结构体的大小是20字节
    25.     // 那么p+1就是就是跳过跳过一个结构体20个字节
    26.  
    27.     //0x100014
    28. //因为这个是16进制的，所以加20个字节就是在这个基础上+14
    29. //4*16的0次方+1*16的1次方就是20
    30.  
    31.     //00100014
    32.  
    33.     printf("%p\n", (unsigned long)p + 0x1);//0x00100001
    34.     //现在将p强制类型转换为整型，那么整型+1就是+1
    35.     //那么得到的就是0x00100001
    36.  
    37.  
    38.  
    39.     printf("%p\n", (unsigned int*)p + 0x1);//00100004
    40.     //将p强制类型转换为int *
    41.     //+1跳过一个unsigned int*类型的指针变量，是4个字节
    42.  
    43.  
    44.     return 0;
    45. }

    题目三 

    1. #include <stdio.h>
    2. int main()
    3. {
    4.     int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    5.     //仔细看，这里用的是小括号不是大括号
    6.     //那么这里就成逗号表达式了
    7.     //(0, 1)的结果就是1
    8.     //(2, 3)的结果就是3
    9.     //(4, 5)的结果就是5
    10.     //int a[3][2] = { 1,3,5 };
    11.     //那么这个二维数组剩下的位置就被0给填充了
    12.     //1  3
    13.     //5  0
    14.     //0  0
    15.  
    16.  
    17.  
    18.  
    19.  
    20.     int* p;//指针
    21.     p = a[0];
    22.     //a[0]是第一行的数组名，
    23.     // 没有sizeof
    24.     // 没有&
    25.     // 
    26.     // 那么表示的就是首元素的地址
    27.     //那么p里面存的就是1的地址
    28.  
    29.     printf("%d", p[0]);
    30.     //p[0]===*p(0)--指向的还是1的位置
    31.     //那么打印出来的就是1
    32.     return 0;
    33. }

    题目四 

    1. //假设环境是x86环境，程序输出的结果是啥？
    2. #include <stdio.h>
    3. int main()
    4. {
    5.     int a[5][5];//5行5列
    6.     //每一行的数组名分别是a[0]、a[1]、a[2]、a[3]、a[4]
    7.  
    8.  
    9.     int(*p)[4];//p是一个数组指针，p指向的数组有4个元素，每个元素是int
    10.     p = a;
    11.     //a是数组名，这个二维数组的数组名，就是第一行的地址，第一行整个一维数组的地址
    12.  
    13.     //第一行的地址的类型就是一个数组指针int(*)[5]
    14.     //p的类型是int(*)[4]   a的类型是int(*)[5]
    15.  
    16.     //不管a原来是什么类型，现在赋值给p，那么现在就是p说的算
    17.  
    18.     //因为a指向的是第一行的位置，那么p同样也指向那里
    19.     //对于p来说，一行只有4个元素
    20.     //p+1就是跳过一行，每行四个元素
    21.  
    22.     printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    23.     //FFFFFFFC,-4
    24.  
    25.     //p[4][2]==*(*(p+4)+2)-----解引用p+4就相当于拿到那一行的数组名
    26.     //两个地址相减是地址直接的元素个数，这中间差了4个元素
    27.     //小地址减去大地址得到的是-4
    28.  
    29.     //第一个代码是打印地址的，因为相减的结果是-4，存在内存里面，那么直接把存放-4的地址打印出来了
    30.     //-4在内存里面存的是补码
    31.     //11111111111111111111111111111100
    32.     //打印地址直接将内存里面的这个二进制补码直接当成地址
    33.     //4个二进制的1就是一个F，最后剩下的1100就是12，转换成6进制就是C
    34.     return 0;
    35. }
    36. //考察的是指针的运算，数组指针+1跳过的是多少
    37. //就是跳过一个指针类型，在这里p+1就是跳过一行

     题目五

    1. #include <stdio.h>
    2. int main()
    3. {
    4.     int aa[2][5] = { 1, 2, 3, 4, 5,    
    5.                      6, 7, 8, 9, 10 };//两行5列
    6.     int* ptr1 = (int*)(&aa + 1);
    7.     //&aa就是取出整个二维数组的地址，+1就是跳过整个二维数组
    8.     //&aa+1得到的还是二维数组的地址，将这个地址强制类型转换为int *
    9.     //因为&aa+1跳过的是整个数组，那么指向的位置就是这个二维数组的末尾
    10.     //因为被强制转换为int *后再赋值给ptr1,那么赋值后ptr1指向的位置也是这个二维数组的末尾
    11.     //
    12.  
    13.  
    14.     int* ptr2 = (int*)(*(aa + 1));//aa+1--->aa[1]---第二行的数组名---第二行首元素的地址
    15.     //aa是数组名，表示的是首元素的地址，就是第一行的地址
    16.     //那么aa+1就是第一行的地址+1指向的就是第二行的地址
    17.     //那么对其进行解引用得到的就是第二行整个一维数组
    18.     //因为这个第二行的一维数组本身就是整型，那么前面的int *可以忽略
    19.  
    20.     //现在将(int*)(*(aa + 1))赋值给ptr2，那么ptr2也是指向的第二行的数组
    21.     //aa + 1可以理解为aa[1]，就是第二行的数组名，就是第二行数组首元素的地址，就是指向的6
    22.  
    23.  
    24.     printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));//10,5
    25.     //在这里，因为ptr1指向的是数组的末尾，并且ptr1是整型指针，那么ptr1-1指向的就是10的位置
    26.     //那么对其进行解引用得到的就是10
    27.  
    28.     //因为ptr2指向的是6，那么ptr2-1得到的就是5的地址，对其进行解引用得到的就是5
    29.  
    30.     return 0;
    31. }

    题目六 

    1. #include <stdio.h>
    2. int main()
    3. {
    4.     char* a[] = { "work","at","alibaba" };
    5.     //正常是不能这么放的，那么就是把每个字符串的首元素地址存在这个指针数组里面了
    6.  
    7.  
    8.     //这里定义的指针数组里面存的分别是w、a、a的地址
    9.  
    10.  
    11.     char** pa = a;//a是数组名，表示的是首元素的地址，就是第一个元素的地址
    12.     //首元素的地址是char*类型的，那么存在pa里面，那么pa就是一个二级指针
    13.     //那么char**pa指向的就是首元素
    14.     pa++;
    15.     //pa指向的是第一个元素，那么++就是指向的第二个元素，就是跳过提个char*类型的指针
    16.     //那么下面的*pa得到的就是第二个元素的地址
    17.     printf("%s\n", *pa);//at
    18.     //得到了地址，那么就从地址开始打印对饮的字符串
    19.     return 0;
    20. }

     题目七--最难的

    1. #include <stdio.h>
    2. int main()
    3. {
    4.     char* c[] = { "ENTER","NEW","POINT","FIRST" };//每个元素是char*
    5.     //存放的是每个字符串首字符的地址，
    6.     //分别是E、N、P、F
    7.  
    8.  
    9.     char** cp[] = { c + 3,c + 2,c + 1,c };
    10.     //c是上面的指针数组的数组名，指向的就是首元素的地址，指向的就是第一个字符串
    11.     //c指向的就是"ENTER"
    12.     //c+1指向的就是"NEW"
    13.     //c+2指向的就是"POINT"
    14.     //c+3指向的就是"FIRST"
    15.  
    16.     //将c里面首元素的地址存放在cp里面，那么cp的类型就是一个二级指针
    17.  
    18.  
    19.  
    20.  
    21.     char*** cpp = cp;
    22.     //cp是数组名，表示的是首元素的地址，将二级指针的地址放在三级指针内
    23.     //cpp指向的是首元素的地址，就是c+3
    24.  
    25.  
    26.     //下面的++和--会有副作用的，会改变指
    27.     //int a=5    ++a   这个动作完了之后a的值就变为6了
    28.  
    29.  
    30.     printf("%s\n", **++cpp);//POINT
    31.     //*  *  ++  cpp
    32.     //先算++cpp,cpp本来放的是c+3的地址，那么现在进行++之后，就指向了c+2的地址
    33.     // 然后解引用，因为cpp现在指向的是c+2的地址，那么第一次解引用就得到了c+2
    34.     // 第二次解引用就是对c+2解引用，得到的就是"POINT"
    35.     //
    36.     //
    37.     //
    38.  
    39.  
    40.     printf("%s\n", *-- * ++cpp + 3);//ER
    41.     //因为加法的优先级比较低，所以先算前面的
    42.     // 所以先算++，再解引用，再--，再解引用
    43.     // 
    44.     // 因为上面的cpp已经进行++操作了，指向的是c+2，那么再次++就是指向的c+1了
    45.     // 那么现在已经得到了c+1的地址了
    46.     // 现在进行解引用通过地址找到c+1，
    47.     // 
    48.     // 原本放的是c+1,现在--就变成c了，就没有c+2了，--就是自减，c+1变成c了
    49.     // c是指向的是"ENTER"这个字符串首元素E的地址，那么解引用完+3指向的就是E
    50.     // //那么就是从E开始打印，所以只能打印ER
    51.     // 
    52.     // 
    53.     // 
    54.     // 
    55.     //
    56.     //
    57.  
    58.  
    59.  
    60.  
    61.     printf("%s\n", *cpp[-2] + 3);//ST
    62.     //*cpp[-2]是**(cpp+(-2))就是**(cpp-2)
    63.     //
    64.     // 一开始cpp指向的是原先的c+1的地址，但是c+1自减了1，就成c了，那么现在cpp指向的就是c的地址了
    65.     // 那么cpp-2得到的就是c+3的地址
    66.     // 这里的cpp-2不会导致cpp的改变，还是指向c
    67.     // 
    68.     // 那么cpp-2得到的是c+2的地址，解引用得到的就是c+3
    69.     // c+3指向的是这串字符串首元素字符F的地址---"FIRST"
    70.     // 
    71.     // 最后F的地址+3就是S
    72.     // 那么打印出来的就是ST
    73.     // 
    74.     // 这里最关键的就是*cpp[-2]这个的理解
    75.     //
    76.  
    77.  
    78.  
    79.     printf("%s\n", cpp[-1][-1] + 1);// EW
    80.     //cpp[-1][-1] + 1
    81.     //转换形式
    82.     // *(*(cpp-1)-1)+1
    83.     // 这里的cpp指向的是c的位置
    84.     // 那么cpp-1就指向了c+2的位置
    85.     // 
    86.     // *(cpp-1)拿到了c+2
    87.     // 那么就变成下面这样了
    88.     // *(（c+2）-1)+1
    89.     // c+2-1得到了c+1,就是现在的cpp指向的位置
    90.     // 
    91.     // c+1指向的就是"NEW"
    92.     //对c+1进行解引用就拿到了"NEW"--N的地址
    93.  
    94.     //然后N的地址+1得到的就是E的地址
    95.     //然后打印出来的就是EW
    96.     return 0;
    97. }
  • 相关阅读:
    大名鼎鼎的OceanBase居然在买Star了？
    期货开户公司想恶意滑点是做不到的
    智能照明控制系统某大楼大厅照明的应用
    Spring中Bean的作用域和生命周期
    云原生中间件 -- MongoDB Operator 篇
    中国智能家居行业市场全景调研与发展前景预测报告
    OpenHarmony开源软件供应链安全风险
    基于约束的装配设计【CadQuery】
    【数据结构】---详解二叉树--- ⌈知识点总结⌋ 和 ⌈常见力扣题目⌋ 确定不来看吗？
    磁盘占用高问题如何排查？三步教你搞定
  • 原文地址：https://blog.csdn.net/2301_80863610/article/details/139590628