【C语言】10.C语言指针（5）

  • 开发
  • 10

文章目录

1.sizeof和strlen的对比

1.1 sizeof

在学习操作符的时候，我们学习了 sizeof ， sizeof 计算变量所占内存内存空间大小的，单位是字节，如果操作数是类型的话，计算的是使用类型创建的变量所占内存空间的大小。

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

#inculde <stdio.h>
int main()
{
    int a = 10;
    printf("%d\n", sizeof(a));
    printf("%d\n", sizeof a);
    printf("%d\n", sizeof(int));

    return 0;
}

打印：

4
4
4

sizeof是操作符不是函数。

1.2 strlen

strlen 是C语言库函数，功能是求字符串长度。

函数原型如下：

size_t strlen ( const char * str );

统计的是从 strlen 函数的参数 str 中这个地址开始向后， \0 之前字符串中字符的个数。

strlen 函数会一直向后找 \0 字符，直到找到为止，所以可能存在越界查找。

#include <stdio.h>
#include <string.h>
int main()
{
    char arr1[3] = {'a', 'b', 'c'};
    char arr2[] = "abc";
    printf("%d\n", strlen(arr1));
    printf("%d\n", strlen(arr2));

    printf("%zd\n", sizeof(arr1));
    printf("%zd\n", sizeof(arr2));
    return 0;
}

打印：

35
3
3
4

在这里插入图片描述

printf("%d\n", strlen(arr1));：因为arr1里面没有\0，所以会往后找到\0才结束，打印的是随机值。

printf("%d\n", strlen(arr2));：因为arr2里面有\0，所以打印3。

printf("%zd\n", sizeof(arr1));：因为arr1里面有3个元素，打印3。

printf("%zd\n", sizeof(arr2));：因为arr2里面有4个元素，打印4。

1.3 sizeof 和 strlen的对⽐

sizeof：

  1. sizeof是操作符
  2. sizeof计算操作数所占内存的大小，单位是字节
  3. 不关注内存中存放什么数据

strlen：

  1. strlen是库函数，使用需要包含头文件 string.h
  2. srtlen是求字符串长度的，统计的是 \0 之前字符的个数
  3. 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，可能会越界

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

2.1 ⼀维数组

数组名是数组首元素地址，但是有两个例外：

  1. sizeof(数组名)
  2. &数组名
int main(){
    int a[] = {1,2,3,4};
    printf("%d\n",sizeof(a));
    printf("%d\n",sizeof(a+0));
    printf("%d\n",sizeof(*a));
    printf("%d\n",sizeof(a+1));
    printf("%d\n",sizeof(a[1]));
    printf("%d\n",sizeof(&a));
    printf("%d\n",sizeof(*&a));
    printf("%d\n",sizeof(&a+1));
    printf("%d\n",sizeof(&a[0]));
    printf("%d\n",sizeof(&a[0]+1));
    
    return 0;
}

打印：

16//sizeof(a)
8//sizeof(a+0)
4//sizeof(*a)
8//sizeof(a+1)
4//sizeof(a[1])
8//sizeof(&a)
16//sizeof(*&a)
8//sizeof(&a+1)
8//sizeof(&a[0])
8//sizeof(&a[0]+1)

printf("%d\n",sizeof(a));：16

数组名a单独放在sizeof内部，a表示整个数组，计算的是整个数组的大小，单位是字节。

printf("%d\n",sizeof(a+0));：8

这里的a是数组名表示数组首元素地址，a+0还是首元素的地址。

这里sizeof计算的是首元素地址的大小，也就是4/8。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n",sizeof(*a));：4

这里的a是数组名表示数组首元素地址，*a是对首元素地址的解引用，也就是首元素，就是a[0]，所以是4个字节。

*a 就是 *(a+0) 就是 a[0]。

printf("%d\n",sizeof(a+1));：8

这里的a是数组名表示数组首元素地址，a+1是第二个元素的地址，也就是a[1]的地址。

这里sizeof计算的是第二个元素地址的大小，也就是4/8。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n",sizeof(a[1]));：4

这里的a[1]就是数组第二个元素，所以是4个字节。

printf("%d\n",sizeof(&a));：8

&a：这里的a表示整个数组，&a就是整个数组的地址。

数组的地址也是地址，和首元素地址大小一样。是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n",sizeof(*&a));：16

这里用两种角度讲一下：

  1. *&a，这里的*和&抵消了，所以sizeof(*&a) == sizeof(a)，计算的是整个数组的大小，单位是字节，也就是16。

  2. &a这是数组的地址，类型是：int(*)[4]，也就是数组指针类型。

    而指针类型，决定了它解引用操作能访问多大空间。

    一个整型指针解引用访问4个字节，一个字符指针解引用访问1个字节，而一个数组指针解引用访问1个数组。

    所以*&a是对一个数组的地址的解引用，访问的是一个数组。这个数组的大小是16个字节。

printf("%d\n",sizeof(&a+1));：8

&a是数组的地址，&a+1是跳过整个数组后的那个地址。

既然&a+1是地址，那么就是4/8个字节。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n",sizeof(&a[0]));：8

&a[0]是数组首元素地址，是地址，那么就是4/8个字节。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n",sizeof(&a[0]+1));：8

&a[0]是数组首元素地址，&a[0]+1是数组第二个元素地址，是地址，那么就是4/8个字节。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

2.2 字符数组

代码1：

char arr[] = {'a','b','c','d','e','f'};//6个字符
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));

打印：

6
8
1
1
8
8
8

printf("%d\n", sizeof(arr));：6

里面有6个字符元素，所以是6。

printf("%d\n", sizeof(arr+0));：8

这里的arr是数组名表示数组首元素地址，arr+0还是首元素的地址。

这里sizeof计算的是首元素地址的大小，也就是4/8。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(*arr));：1

这里的arr是数组名表示数组首元素地址，*arr是对首元素地址的解引用，也就是首元素，就是arr[0]，所以是1个字节。

printf("%d\n", sizeof(arr[1]));：1

这里的arr[1]就是字符数组第二个元素，所以是1个字节。

printf("%d\n", sizeof(&arr));：8

&arr：这里的arr表示整个数组，&arr就是整个数组的地址。

数组的地址也是地址，和首元素地址大小一样。是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(&arr+1));：8

&arr是数组的地址，&arr+1是跳过整个数组后的那个地址。

既然&arr+1是地址，那么就是4/8个字节。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(&arr[0]+1));：8

&arr[0]是数组首元素地址，&arr[0]+1是数组第二个元素地址，是地址，那么就是4/8个字节。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

代码2：

char arr[] = {'a','b','c','d','e','f'};
printf("%zd\n", strlen(arr));
printf("%zd\n", strlen(arr+0));
printf("%zd\n", strlen(*arr));
printf("%zd\n", strlen(arr[1]));
printf("%zd\n", strlen(&arr));
printf("%zd\n", strlen(&arr+1));
printf("%zd\n", strlen(&arr[0]+1));

printf("%d\n", strlen(arr));：随机值

因为arr是首元素地址，我们不知道里面有没有\0，也不知道\0之前有多少个字符

printf("%d\n", strlen(arr+0));：随机值

因为arr+0是首元素地址，我们不知道里面有没有\0，也不知道\0之前有多少个字符

而且这个打印的随机值，应该是和上面打印的随机值一样的

printf("%d\n", strlen(*arr));：这个地方程序直接就崩了

这个*arr是对首元素地址的解引用，得到的是arr[0]的值。

arr[0]是'a'，a的ASCII码值是97。

就相当于把97传给了strlen，strlen就会把97当成地址去访问。

这个地方程序直接就崩了。

在这里插入图片描述

这里的61是16进制，换成10进制就是97。

printf("%d\n", strlen(arr[1]));：这个地方程序直接就崩了

arr[1]是'b'，b的ASCII码值是98。

就相当于把98传给了strlen，strlen就会把98当成地址去访问。

这个地方程序直接就崩了。

printf("%d\n", strlen(&arr));：随机值

&arr是数组的地址，我们不知道里面有没有\0，也不知道\0之前有多少个字符

而且这个打印的随机值，应该是和上面打印的随机值一样的

printf("%d\n", strlen(&arr+1));：随机值

&arr是数组的地址，&arr+1是跳过整个数组后的那个地址。

我们不知道里面有没有\0，也不知道\0之前有多少个字符

而且这个打印的随机值，应该比上面打印的随机值少6。因为跳过了这个数组，这个数组 里面有6个元素。

printf("%d\n", strlen(&arr[0]+1));：随机值

&arr[0]是数组首元素地址，&arr[0]+1是数组第二个元素地址。

我们不知道里面有没有\0，也不知道\0之前有多少个字符

而且这个打印的随机值，应该比上面打印的随机值少1。因为跳过了第一个数组元素。

代码3：

char arr[] = "abcdef";
printf("%d\n", sizeof(arr));
printf("%d\n", sizeof(arr+0));
printf("%d\n", sizeof(*arr));
printf("%d\n", sizeof(arr[1]));
printf("%d\n", sizeof(&arr));
printf("%d\n", sizeof(&arr+1));
printf("%d\n", sizeof(&arr[0]+1));

打印：

7
8
1
1
8
8
8

数组名是数组首元素地址，但是有两个例外：

  1. sizeof(数组名)
  2. &数组名

printf("%d\n", sizeof(arr));：7

数组名单独放在sizeof内部，计算的是数组的大小。（满足上面的第一个例外）

printf("%d\n", sizeof(arr+0));：8

arr+0是数组首元素地址。是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(*arr));：1

*arr是首元素 ，sizeof(*arr)就是1。

printf("%d\n", sizeof(arr[1]));：1

arr[1]是数组第二个元素，sizeof(arr[1])就是1。

printf("%d\n", sizeof(&arr));：8

&arr是数组的地址。是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(&arr+1));：8

&arr+1是跳过整个数组，指向数组后的那个位置的地址。是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(&arr[0]+1));：8

&arr[0]是首元素地址，&arr[0]+1是数组第二个元素的地址。是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

代码4：

char arr[] = "abcdef";
printf("%d\n", strlen(arr));
printf("%d\n", strlen(arr+0));
printf("%d\n", strlen(*arr));
printf("%d\n", strlen(arr[1]));
printf("%d\n", strlen(&arr));
printf("%d\n", strlen(&arr+1));
printf("%d\n", strlen(&arr[0]+1));

printf("%d\n", strlen(arr));：6

arr是数组首元素地址，strlen是从第一个元素开始统计\0之前的字符个数。

printf("%d\n", strlen(arr+0));：6

arr+0是数组首元素地址，strlen是从第一个元素开始统计\0之前的字符个数。

printf("%d\n", strlen(*arr));：这个地方程序直接就崩了

*arr是数组第一个元素，也就是'a'，a的ASCII码值是97。

就相当于把97传给了strlen，strlen就会把97当成地址去访问。

这个地方程序直接就崩了。

printf("%d\n", strlen(arr[1]));：这个地方程序直接就崩了

arr[1]是数组第二个元素，也就是'b'，b的ASCII码值是98。

就相当于把98传给了strlen，strlen就会把98当成地址去访问。

这个地方程序直接就崩了。

printf("%d\n", strlen(&arr));：6

&arr是数组的地址，数组的地址和数组首元素的地址是指向同一个位置的。

那么strlen也是从第一个元素的位置开始向后访问的。

printf("%d\n", strlen(&arr+1));：随机值

&arr是数组的地址，&arr+1是跳过整个数组后的那个地址。

我们不知道里面有没有\0，也不知道\0之前有多少个字符

而且这个打印的随机值，应该比上面打印的随机值少6。因为跳过了这个数组，这个数组 里面有6个元素。

printf("%d\n", strlen(&arr[0]+1));：5

&arr[0]是首元素地址，&arr[0]+1是数组第二个元素的地址。

那么strlen是从第二个元素的位置开始向后访问的。

代码5：

char *p = "abcdef";
printf("%d\n", sizeof(p));
printf("%d\n", sizeof(p+1));
printf("%d\n", sizeof(*p));
printf("%d\n", sizeof(p[0]));
printf("%d\n", sizeof(&p));
printf("%d\n", sizeof(&p+1));
printf("%d\n", sizeof(&p[0]+1));

打印:

8
8
1
1
8
8
8

数组名是数组首元素地址，但是有两个例外：

  1. sizeof(数组名)
  2. &数组名

printf("%d\n", sizeof(p));：8

p是指针变量。sizeof(p)计算的是指针变量p的大小，4/8个字节。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(p+1));：8

在这里插入图片描述

p是指针变量。我们假设p的地址是：0x0012ff40，p+1的地址是：0x0012ff41

也就是第二个元素的地址。

sizeof(p+1)计算的是二个元素的地址的大小，4/8个字节。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(*p));：1

p的类型是char*，*p解引用只能访问一个字符，所以sizeof(*p)为1。

printf("%d\n", sizeof(p[0]));：1

p[0]就是*(p+0)也就是*p，*p解引用只能访问一个字符，所以sizeof(*p)为1。

printf("%d\n", sizeof(&p));：8

&p是指针变量p的地址。是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(&p+1));：8

&p的类型是char* *，也就相当于char* *ptr = &p;

前面的char*说明ptr指向的对象是char*，这里的*ptr说明ptr是一个指针。

在这里插入图片描述

&p+1相当于ptr+1，也就相当于它跳过了一个char*的指针。

在这里插入图片描述

跑到了图中橙色箭头的地方。和b没什么关系。

&p是p的地址，&p+1是跳过p变量，指向了p的后面。

是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n", sizeof(&p[0]+1));：8

p[0]就是*(p+0)就是*p

&p[0]就是*&p[0]，实际上就是p。

&p[0]+1就是b的地址。

是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

代码6：

char *p = "abcdef";
printf("%d\n", strlen(p));
printf("%d\n", strlen(p+1));
printf("%d\n", strlen(*p));
printf("%d\n", strlen(p[0]));
printf("%d\n", strlen(&p));
printf("%d\n", strlen(&p+1));
printf("%d\n", strlen(&p[0]+1));

printf("%d\n", strlen(p));：6

p是指针变量。p里面存的是a的地址，指向的是字符串首元素的地址。

printf("%d\n", strlen(p+1));：5

p是指针变量。p里面存的是a的地址，p+1里面存的是b的地址，指向的是字符串第二个元素的地址。

printf("%d\n", strlen(*p));：程序崩溃

*p是数组第一个元素，也就是'a'，a的ASCII码值是97。

就相当于把97传给了strlen，strlen就会把97当成地址去访问。

这个地方程序直接就崩了。

printf("%d\n", strlen(p[0]));：程序崩溃

p[0]也就是*(p+0)也就是*p。

*p是数组第一个元素，也就是'a'，a的ASCII码值是97。

就相当于把97传给了strlen，strlen就会把97当成地址去访问。

这个地方程序直接就崩了。

printf("%d\n", strlen(&p));：随机数

&p是指针变量p的地址。

如果p的地址是0x0012ff40，那么就是去p的内存空间里面去找的。

我们不知道里面有没有\0，也不知道\0之前有多少个字符

printf("%d\n", strlen(&p+1));：随机值

&p是指针变量p的地址。&p+1是指向指针变量p后面的地址。

我们不知道里面有没有\0，也不知道\0之前有多少个字符

printf("%d\n", strlen(&p[0]+1));：5

&p[0]是首元素地址，&p[0]+1是第二个元素地址。

2.3 ⼆维数组

int a[3][4] = {0};
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(a[0][0]));
printf("%d\n",sizeof(a[0]));
printf("%d\n",sizeof(a[0]+1));
printf("%d\n",sizeof(*(a[0]+1)));
printf("%d\n",sizeof(a+1));
printf("%d\n",sizeof(*(a+1)));
printf("%d\n",sizeof(&a[0]+1));
printf("%d\n",sizeof(*(&a[0]+1)));
printf("%d\n",sizeof(*a));
printf("%d\n",sizeof(a[3]));

打印：

48
4
16
8
4
8
16
8
16
16
16

讲这个前面我们先复习一下：

在这里插入图片描述

我们一般说的时候是理解上面的那个3x4的图的，但是实际上内存里是连续存放的，也就是说内存里是像下面这样1x12这么放的。

数组名是数组首元素地址，但是有两个例外：

  1. sizeof(数组名)
  2. &数组名

printf("%d\n",sizeof(a));：48

a作为数组名，单独放在sizeof内部，a表示的是整个数组，计算的是整个数组的大小，单位是字节。

三行四列12个元素。每个元素乘4。

printf("%d\n",sizeof(a[0][0]));：4

a[0][0]是第一行第一列元素，大小是4个字节。

printf("%d\n",sizeof(a[0]));：16

a[0]是第一行的数组名，单独放在sizeof内部，计算的是数组的大小。

第一行4个元素，也就是4x4是16个字节。

printf("%d\n",sizeof(a[0]+1));：8

这里面a[0]是第一行的数组名，但是没有单独放在sizeof内部。所以这个a[0]表示的是首元素地址。&a[0][0]

也就是第一行第一个数组元素的地址。

a[0]+1就等价于&a[0][0]+1就等价于&a[0][1]。

也就是a[0][1]的地址。

是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n",sizeof(*(a[0]+1)) );：4

a[0]+1就等价于&a[0][0]+1就等价于&a[0][1]。

*(a[0]+1)就相当于*&a[0][1]就相当于a[0][1]。

一个元素，也就相当于1x4等于4个字节。

printf("%d\n",sizeof(a+1));：8

a是二维数组的名字，并没有单独放在sizeof内部，

a表示的是首元素的地址，也就是第一行的地址。类型是int(*)[4]

a+1是第二行的地址。

是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n",sizeof(*(a+1)) );：16

下面从两个角度讲一下：

  1. *(a+1)其实就是a[1]，也就是第二行的数组名，单独放在sizeof内部，计算的是第二行的大小。

    第二行4个元素，也就是4x4等于16个字节。

  2. a+1是第二行的地址，类型是int(*)[4]，解引用访问的是这个数组a[1]，

    第二行4个元素，也就是4x4等于16个字节。

printf("%d\n",sizeof(&a[0]+1));：8

&a[0]是第一行的数组名，&数组名，表示第一行的地址，&a[0]+1就是第二行地址，

是地址就是4/8个字节的长度。

因为我编译的环境是x64，所以是8，如果是x86的环境下编译，那么就是4。

printf("%d\n",sizeof(*(&a[0]+1)) );：16

&a[0]是第一行的数组名，&数组名，表示第一行的地址，&a[0]+1就是第二行地址，

*(&a[0]+1))第二行的地址解引用，就是第二行。

第二行4个元素，也就是4x4等于16个字节。

printf("%d\n",sizeof(*a));：16

下面从两个角度讲一下：

  1. a是首元素的地址，也就是第一行的地址 ，*a就是第一行的元素。

    第一行4个元素，也就是4x4等于16个字节。

  2. *a就是*(a+0)就是a[0],就是第一行的元素。

    第一行4个元素，也就是4x4等于16个字节。

printf("%d\n",sizeof(a[3]));：16

乍一看越界了，但其实程序还是可以运行的。

为什么呢?

因为sizeof内部的表达式是不会真实计算的。

就像a[3]是第四行的数组名，但他不会真实去访问第四行，也就谈不上越界。

那这里为什么会算出结果呢？

因为a[3]第四行的数组名，他的类型是int[4](如果第四行存在的话 ， 就是这个类型)

第四行4个元素，也就是4x4等于16个字节。（也就相当于说sizeof是根据类型来推断的）

数组名的意义：

  1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
  2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
  3. 除此之外所有的数组名都表示首元素的地址。

3.指针运算笔试题解析

3.1 题⽬1

程序的结果是什么？

#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;
}

打印：

2,5

为什么呢?

在这里插入图片描述

3.2 题⽬2

在X86环境下

假设结构体的大小是20个字节

程序的结果是什么？

struct Test
{
    int Num;
    char *pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{
    printf("%p\n", p + 0x1);
    printf("%p\n", (unsigned long)p + 0x1);
    printf("%p\n", (unsigned int*)p + 0x1);
    return 0;
}

打印：

00100014
00100001
00100004

为什么呢?

  1. 指针+1和类型有关系。

  2. 整数+1就是+1。

printf("%p\n", p + 0x1);

p + 0x1这个0x1是十六进制，也就是说这里其实是p + 1

p是结构体指针，+1就是跳过一个结构体，也就是20个字节（20字节这个条件前面给了）

这里相当于就是0x100014

printf("%p\n", (unsigned long)p + 0x1);

把指针变量p强制类型转换成unsigned int，也就相当于整数+1。

0x100001

printf("%p\n", (unsigned int*)p + 0x1);

+1是跳过一个unsigned int类型的变量，是4个字节。

也就是0x100004

3.3 题⽬3

程序的结果是什么？

#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

为什么呢?

int a[3][2] = { (0, 1), (2, 3), (4, 5) };

注意这里面，用的是小括号，这就意味着这些小括号里其实是逗号表达式。

我们可以认为上面的代码就是：

int a[3][2] = { 1, 3, 5 };

数组里面：

1 3
5 0
0 0

a[0]是首元素地址，p是一个指针变量。

p[0]就等价于*(p+0)就等价于*p。

也就是1。

3.4 题⽬4

假设环境是x86环境，程序输出的结果是啥？

#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;
}

打印：

FFFFFFFC,-4

为什么呢?

int(*p)[4];

p是一个数组指针，指向的类型是int，p指向的数组有4个元素。

p = a;

a的类型是int(*)[5]

p的类型是int(*)[4]

最后会采用p的类型。

printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);

p[4][2]和*(*(p+4)+2)等价。

*(p+4)就是p+4和p+5之间的那段。

在这里插入图片描述

p[4][2]和a[4][2]之间差了4个元素，所以&p[4][2] - &a[4][2]等于-4。

%d是十进制形式

%p是补码形式

//-4
//原码
10000000 00000000 00000000 00000100
//反码
11111111 11111111 11111111 11111011
//补码
11111111 11111111 11111111 11111100

写成16进制就是：

0xFF FF FF FC

3.5 题⽬5

程序的结果是什么？

#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;
}

打印：

10,5

为什么呢?

在这里插入图片描述

3.6 题⽬6

程序的结果是什么？

#include <stdio.h>
int main()
{
    char *a[] = {"work","at","alibaba"};
    char**pa = a;
    pa++;
    printf("%s\n", *pa);
    return 0;
}

打印：

at

为什么呢?

char *a[] = {"work","at","alibaba"};

这个是char*的指针数组，里面有3个元素，分别是w的地址，at里面a的地址，alibaba里面a的地址。（也就是三个字符串的首地址）

char**pa = a;

a表示首元素地址。char**这个二级指针变量pa里面存的是a的第一个元素的地址。即指向字符串 work 的指针。

pa++;

这行代码将 pa 指针向前移动一个位置，即指向数组 a 的第二个元素，也就是指向字符串 at 的指针。

printf("%s\n", *pa);

这行代码通过解引用 pa 指针（即 *pa ），打印出它当前指向的字符串 at，并换行。

%s打印的是地址，是从这个地址往后打印字符串。

3.7 题⽬7

程序的结果是什么？

#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;
}

打印：

POINT
ER
ST
EW

为什么呢?

  1. printf("%s\n", **++cpp);

在这里插入图片描述

然后%s往后打印，打印POINT。

  1. printf("%s\n", *--*++cpp+3);

在这里插入图片描述

然后%s往后打印，打印ER。

  1. printf("%s\n", *cpp[-2]+3);

在这里插入图片描述

然后%s往后打印，打印ST。

  1. printf("%s\n", cpp[-1][-1]+1);

在这里插入图片描述

然后%s往后打印，打印EW。

阅读全部

相关推荐

  4. 【C语言】（12）指针

    2024-06-08 22:56:01       28 阅读

  6. C语言K&R圣经笔记 5.11函数指针

    2024-06-08 22:56:01       32 阅读

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

    2024-06-08 22:56:01       7 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-06-08 22:56:01       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-06-08 22:56:01       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-06-08 22:56:01       18 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-06-08 22:56:01       20 阅读

热门阅读

  1. 一文搞懂 reST 和 Markdown 语法

    2024-06-08 22:56:01       9 阅读

  3. 基于Flask的python后端，组合支付记录，充值余额+赠送余额+微信支付功能实现详解

    2024-06-08 22:56:01       10 阅读

  9. 鸿蒙认证学什么？

    2024-06-08 22:56:01       12 阅读

  11. NoSuchModuleError: Can‘t load plugin: sqlalchemy.dialects:clickhouse解决方案

    2024-06-08 22:56:01       7 阅读

  15. 力扣 41.缺少的第一个正整数

    2024-06-08 22:56:01       10 阅读

  16. Python爬虫实战：从入门到精通

    2024-06-08 22:56:01       8 阅读

  17. 系统架构设计师【补充知识】: 专业英语 (核心总结)

    2024-06-08 22:56:01       8 阅读

  21. 连接ssl加密的kafka集群

    2024-06-08 22:56:01       8 阅读

  22. uniapp 小程序运行报错plus...

    2024-06-08 22:56:01       9 阅读

  24. 每天一个数据分析题（三百四十八）

    2024-06-08 22:56:01       8 阅读

  25. 如何自定义SpringBoot的白标错误页面？

    2024-06-08 22:56:01       9 阅读

  27. Python中的函数式编程概念

    2024-06-08 22:56:01       8 阅读

  30. uni-app学习--基础组件使用、页面生命周期、本地存储、网络请求、条件编译、路由跳转

    2024-06-08 22:56:01       9 阅读