当前位置：首页 > article >正文

C语言进阶之笔试题详解(1)

article 2024/11/19 6:27:15

引言：

对指针知识进行简单的回顾，然后再完成笔试题。

✨ 猪巴戒：个人主页✨

所属专栏：《C语言进阶》

🎈跟着猪巴戒，一起学习C语言🎈

引言：

知识简单回顾

指针是什么

指针变量的大小？

指针类型的意义

指针的运算

指针数组

数组名是什么

数组指针

函数指针

函数指针数组

回调函数

笔试题

一维数组

题目：

解析：

总结：

字符数组

题目1：

解析：

题目2：

解析：

总结：

题目3：

解析：

总结：

题目4：

解析：

总结：

题目5：

答案：

题目6：

答案：

知识简单回顾

指针是什么

内存 ->内存的单元（1byte）->编号->地址

我们有一块很大的内存空间，内存空间被分为一个一个的单元，一个内存单元的大小是1byte(字节)，每个字节都有它的编号，这个编号就是地址，地址又叫做指针。

指针就是一个地址。

我们口头语说的指针一般指：指针变量

指针变量就是一个变量，就是一块内存空间，指针变量用来存放地址。

&a就是内存的编号，也是地址.
这个指针变量叫做pa,int*是类型（整形指针），通过这个类型创造的变量叫做pa。

*pa就是对pa进行解引用，通过pa存放的地址找到它所指向的对象（a）,pa存的是a的地址所以pa指向a,*pa其实就是a。

*pa = 20；就相当于 a = 20；将 a 的值改变了。

int main()
{
    int a = 0;

    int* pa = &a;

    *pa = 20;

    return 0;
}

指针变量的大小？

——4/8个字节，取决于编译器是x86环境还是x64环境

指针类型的意义

两件事情：

1.指针类型进行+1/-1的操作时，它会跳过几个字节。

2.进行解引用操作的时候，决定了解引用操作时候的权限，（访问多少个字节）

指针的运算

1。+-整数

2.指针-指针

3.指针的关系运算

指针数组

本质上就是数组，数组中存放的是指针（地址）。

arr 存放了三个元素，每个元素都是int*类型，也就是指针，那么arr就是指针数组。

int main()
{
    int *pa;
    int *pb;
    int *pc;
    int* arr = { pa,pb,pc };
    return 0;
}

数组名是什么

1.数组名在大部分情况下表示数组首元素的地址，

但是有两个例外：

a）sizeof（数组名），表示的是整个数组的大小

b）&数组名，取出的是整个数组的地址

数组指针

&数组名，这里的parr ,存放的是数组的地址，parr为数组指针。

数组指针：int (*parr)[10]，parr与*结合，代表parr为指针，[10]表示parr指向数组，数组中元素的类型是int。

指针数组：int* parr[10],没有括号，parr与[10]结合，表示parr为数组，数组中元素的类型是int*(整形指针)

数组指针类型的表示：int (*)[10];

int arr[10] = {1,2,3};
int (*parr)[10] = &arr;

函数指针

函数指针就是函数的地址，函数也有地址，我们可以通过函数的地址去使用函数。

函数的地址存放在函数指针变量中，

函数指针类型表示：

int (*)(int,int)

int (*pf)(int ,int)，pf与*结合，表示pf是指针，指针指向的是(int , int)参数是两个整形的函数，函数的返回类型是int。

int Add(int x,int y)
{
    return x + y;
}

int main()
{
    int (*pf)(int ,int) = &Add;
    int sum = (*pf)(2,3);
    //Add 和 &函数名一样，Add也可以直接表示为地址,因此也可以写成这种形式
    //int (*pf)(int ,int) = Add;
    //Add传给了pf，pf 等同于 Add ,那么我们也可以这样写。 
    //int sum = pf(2.3)
    return 0;
}

函数指针数组

存放函数指针的数组。

我们将函数指针数组命名为arr，arr数组的每个元素的类型是：int (*)(int,int)

函数指针数组的类型表示：

int （*[4])(int,int)

怎么理解这函数指针数组的形式？

arr与[4]结合，说明arr是数组，这个数字的每个元素是int(*)(int,int),而这正好是函数指针类型。

int （*arr[4])(int,int) = {Add,Sub,Div,Mul};

回调函数

通过函数指针调用的函数就是回调函数。

这里的函数指针是pf，pf指向的函数是Add，通过pf调用Add，我们称Add为回调函数。

int Add(int x,int y)
{
    return x + y;
}

int main()
{
    int (*pf)(int ,int) = Add;
    int sum = pf(2.3);
    return 0;
}

笔试题

一维数组

题目：

以下打印的结果分别是什么？

 int a[] = {1,2,3,4};
1|printf("%d\n",sizeof(a));
2|printf("%d\n",sizeof(a+0));
3|printf("%d\n",sizeof(*a));
4|printf("%d\n",sizeof(a+1));
5|printf("%d\n",sizeof(a[1]));
6|printf("%d\n",sizeof(&a));
7|printf("%d\n",sizeof(*&a));
8|printf("%d\n",sizeof(&a+1));
9|printf("%d\n",sizeof(&a[0]));
10|printf("%d\n",sizeof(&a[0]+1));

数组名的理解，指针的运算和指针类型的意义

解析：

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

sizeof(数组名），数组名表示整个数组，计算的是整个数组的大小，单位是字节

2.printf (" %d\n ", sizeof( a+0 ) ); 4 / 8

a不是单独放在sizeof内部，也没有取地址，所以a就是首元素的地址，a+0还是首元素的地址。是地址，大小就是4 / 8个字节。地址的大小和环境有关，32位的系统环境就是4个字节，64位系统环境就是8个字节。

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

*a中的a是数组数组首元素的地址，*a就是对首元素的地址解引用，找到的就是首元素，

首元素是整形，所占内存大小是4个字节

4.printf (" %d\n ", sizeof( a+1 ) ); 4 / 8

a不是单独放在sizeof的内部，a表示的是首元素的地址，a+1就是数组第二个元素的地址

地址的大小是4个字节或者8个字节。

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

a[1]表示的是数组的第二个元素，作为整形元素的大小为4个字节

6.printf (" %d\n ", sizeof( &a ) ); 4 / 8

&a,&数组名，这里的a表示的是整个数组的地址，一共4个元素，地址的大小是4个字节。虽然说是整个数组的地址，但是还是通过首元素的地址来表达。

注意：首元素的地址和数组的地址虽然表现是同一个地址，但是它们的运算的结果是不一样的。

比如：&a+1和a+1,一个表示的是跳过了一个（4个整形元素的）数组的地址，一个表示的是数组第二个元素的地址

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

&a取的是整个数组的地址，对&a进行解引用，得到的是整个数组，一共4个元素，一个整形元素的大小为4个字节，一共是16个字节

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

&数组名，取的是整个数组的地址，&a再加上1，就是跳过一个数组的位置，然后再取了一个相同大小数组的地址。&a+1还是地址，地址的大小就是4 / 8个字节。

9.printf (" %d\n ", sizeof( &a[0] ) ); 4 / 8

&a[0]取的是数组第一个元素的地址，大小是4个字节或者8个字节。

10.printf (" %d\n ", sizeof( &a[0]+1 ) ); 4 / 8

&a[0],取的是数组第一个元素的地址，&a[0]+1就是数组第二个元素的地址。大小是4个字节或者8个字节。

总结：

1.数组名大多数表示首元素的地址，有两个例外：1.sizeof（数组名）2.&数组名。数组名表示的是整个数组。

2.不同类型地址跳过的字节不一样，&a+1，&a表示的是整个数组，+1就会跳过一个数组的大小。&a[0]+1,&a[0]是数组第一个元素的地址，所以+1跳过的是一个元素的大小。

3.地址意义可能不同，但是地址的大小都是4 / 8个字节。

字符数组

题目1：

以下打印的结果是什么？

char arr[] = {'a','b','c','d','e','f'};
1|printf("%d\n",sizeof(arr));
2|printf("%d\n",sizeof(arr+0));
3|printf("%d\n",sizeof(*arr));
4|printf("%d\n",sizeof(arr[1]));
5|printf("%d\n",sizeof(&arr));
6|printf("%d\n",sizeof(&arr+1));
7|printf("%d\n",sizeof(&arr[0]+1));

解析：

1| printf (" %d\n " , sizeof ( arr ) ) 6

sizeof(数组名)，取的是整个数组的大小，字符数组arr一共6个元素，所以大小为6个字节。

2|printf (" %d\n ", sizeof( arr+0 ) ) 4 / 8

arr并没有单独放在sizeof内部，所以arr表示首元素的地址，arr+0也表示首元素的地址。是地址，那么大小就为4个字节或者8个字节。

3|printf (" %d\n ",sizeof ( *arr ) ) 1

arr是首元素的地址，就是 ‘a’ 的地址，然后解引用，就是‘a’，char类型，大小是1个字节。

*arr 等价于arr [ 0 ]

*(arr+0) 等价于 arr [ 0 ]

4|printf (" %d\n ", sizeof( arr[1] ) ) 1

arr[1]是数组第二个元素，‘b'，大小是1个字节。

5|printf (" %d\n ", sizeof( &arr ) ) 4 / 8

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

6|printf (" %d\n ", sizeof( &arr+1 ) ) 4 / 8

&arr取的是arr数组的地址，&arr+1跳过一个（6个字符元素的）数组，下图是&arr+1的地址位置，是地址，大小就是4个字节或者8个字节。

7|printf (" %d\n ", sizeof( &arr[0]+1 ) ) 4 / 8

&arr[0]取的是数组第一个元素的地址，&arr[0]+1就是第二个元素的地址，是地址，就是4个字节或者8个字节。

题目2：

以下的打印结果分别是什么？

char arr[] = {'a','b','c','d','e','f'};
1|printf("%d\n",strlen(arr));
2|printf("%d\n",strlen(arr+0));
3|printf("%d\n",strlen(*arr));
4|printf("%d\n",strlen(arr[1]));
5|printf("%d\n",strlen(&arr));
6|printf("%d\n",strlen(&arr+1));
7|printf("%d\n",strlen(&arr[0]+1));

解析：

strlen

用来求字符串长度的库函数，参数是地址，从参数传来的地址开始，直到有' \0 '停止。

1|printf (" %d\n ", strlen ( arr ) ) 随机值

arr为数组首元素的地址，字符数组没有' \0 ',strlen会运行完数组，还会继续运行，直到遇到' \0',但是数组外的元素不由数组控制，也就是说，' \0 '什么时候出现是不可知的，所以会打印随机值。

下图遇到' \0 '前一共19个元素，所以打印结果为19。

' \0 '的ASCII的数字就是0.

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

arr+0也是首元素的地址，其实和前面问题的随机值是一样的。这里也将会在第20个元素遇到 ‘\0’，所以这里的随机值与 1| 一样。

3|printf (" %d\n ", strlen ( *arr ) ) 访问冲突

strlen的参数是地址，而*arr传过去的是 ’a‘ ，’a'的ASCII值为97，，不是一个地址，就会发生访问冲突，也就是野指针问题。

4|printf (" %d\n ", strlen ( arr[1] ) ) 访问冲突

和前面一个问题产生的结果一样，既然strlen函数的参数是地址，将值传过去就会产生野指针的问题。

5|printf (" %d\n ", strlen ( &arr ) ) 随机值

&arr传过去的是整个数组的地址，strlen用const char* str来接收，那么strlen又是怎么运行的呢？这里的地址和1|、2|类型不同，但是地址的位置是相同的，strlen也应该是从首元素开始一个一个筛查，直到遇到 ‘\0’ ，求字符串才算结束。所以这里和1|、2|的结果应该是一样的。

6|printf (" %d\n ", strlen ( &arr+1 ) ) 随机值 - 6

&arr+1，&arr取的是整个数组的地址，&arr+1会跳过一个（6个char类型元素的）数组，下图标记&arr+1的地址位置，strlen函数也就是从这里开始运行，直到遇到 ‘\0’ ,那么这里的结果就会比1|、2|、5|的结果少6个元素。结果：随机值 - 6

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

&arr[0]取的是数组第一个元素的地址，&arr[0]+1就是数组第二个元素的地址，从第二个元素开始，strlen遇到 '\0' 停止，就会比1|、2|、5|的结果少1个元素。结果：随机值 - 1.

总结：

1.strlen（const char* str）传递的参数是地址，如果传递数值的话，就会产生访问冲突的问题。

2.strlen不管地址的类型，只管地址的位置，从地址的位置开始，逐个去数字符，直到遇到 \0 ,strlen就停止运行，求出字符串的长度。

题目3：

以下打印的结果是什么？

char arr[] = "abcdef";
1|printf("%d\n",sizeof(arr));
2|printf("%d\n",sizeof(arr+0));
3|printf("%d\n",sizeof(*arr));
4|printf("%d\n",sizeof(arr[1]));
5|printf("%d\n",sizeof(&arr));
6|printf("%d\n",sizeof(&arr+1));
7|printf("%d\n",sizeof(&arr[0]+1));

解析：

char arr[] = "abcdef",这个数组的元素为[ a b c d e f \0 ],一共7个元素，字符串默认以 \0 结尾。

1|printf (" %d\n ", sizeof ( arr ) ) 7

sizeof(数组名)，这里的数组名表示的是整个数组，因为字符串默认为 ‘\0’ 结尾，所以这个数组有7个元素，结果为7个字节。

2|printf (" %d\n ", sizeof ( arr+0 ) ) 4 / 8

arr表示的是首元素的地址，arr+0表示首元素的地址，是地址，地址的大小为4个字节或者8个字节。

3|printf (" %d\n ", sizeof ( *arr ) ) 1

arr表示首元素的地址，*arr取的是‘a’,大小为1个字节。

4|printf (" %d\n ", sizeof ( arr[1] ) ) 1

arr[1]为数组的第二个元素，‘b’，大小为1个字节。

5|printf (" %d\n ", sizeof ( &arr ) ) 4 / 8

&arr取的是整个数组的地址，地址的大小为4个字节或者8个字节。

6|printf (" %d\n ", sizeof ( &arr+1 ) ) 4 / 8

&arr取的是整个数组的地址，&arr+1跳过1个（7个元素）的数组，跳过一个数组，但是地址的类型是不变的，是还是一个数组的地址，不过既然是地址，地址的大小为4个字节或者8个字节。

7|printf (" %d\n ", sizeof ( &arr[0]+1 ) ) 4 / 8

&arr[0]取的是数组第一个元素的地址，&arr+1就是数组第二个元素的地址，地址的大小为4个字节或者8个字节。

总结：

1.不管地址的类型是什么，只要是地址，地址的大小就是4个字节或者8个字节。

2.字符串相当于普通的字符数组，但是字符串通常默认 \0 为结尾。

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

题目4：

以下打印的结果是什么？

char arr[] = "abcdef";
1|printf("%d\n",strlen(arr));
2|printf("%d\n",strlen(arr+0));
3|printf("%d\n",strlen(*arr));
4|printf("%d\n",strlen(arr[1]));
5|printf("%d\n",strlen(&arr));
6|printf("%d\n",strlen(&arr+1));
7|printf("%d\n",strlen(&arr[0]+1));

解析：

char arr[] = "abcdef",这个数组的元素为[ a b c d e f \0 ],一共7个元素，字符串默认以 \0 结尾。

strlen是求字符串长度的，关注的是字符串中的 \0 ，计算的是 \0 之前出现的字符的个数。

1|printf (" %d\n" , strlen ( arr ) ) 6

arr是首元素的地址，遇到 \0 停止。结果：6

2|printf (" %d\n ", strlen ( arr+0 ) ) 6

3|printf (" %d\n ", strlen ( *arr ) ) 访问冲突

传递的不是地址。

4|printf (" %d\n ", strlen ( arr[1] ) ) 访问冲突

传递的不是地址。

5|printf (" %d\n ", strlen ( &arr ) ) 6

取的是整个数组的地址，但是地址位置是首元素的地址。

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

跳过了一个数组，\0也包括在这个数组里面，strlen就会往下去寻找 \0 ,结果会是随机值。

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

从第二个元素开始，后面遇到 \0,一共是5个元素。

总结：

1. strlen是求字符串长度的，关注的是字符串中的 \0 ，计算的是 \0 之前出现的字符的个数。

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

题目5：

char* p = "abcdef";
1|printf("%d\n",sizeof(p));
2|printf("%d\n",sizeof(p+1));
3|printf("%d\n",sizeof(*p));
4|printf("%d\n",sizeof(p[0]));
5|printf("%d\n",sizeof(&p));
6|printf("%d\n",sizeof(&p+1));
7|printf("%d\n",sizeof(&p[0]+1));

答案：

这里的“abcdef”并不是数组，而是常量字符串，常量字符串在内存中有独立的地址。p接收的是首元素’a‘的地址。

1|printf (" %d\n ", sizeof ( p ) ) 4 / 8

p是指针变量，存放的是’a‘的地址。地址的大小为4个字节或者8个字节。

2|printf (" %d\n ", sizeof ( p+1 ) ) 4 / 8

p+1是地址。

3|printf (" %d\n ", sizeof ( *p ) ) 1

*p是 ’a‘，大小是1个字节

4|printf (" %d\n ", sizeof ( p[0] ) ) 1

p[0]是’a‘，大小是1个字节。

5|printf (" %d\n ", sizeof ( &p ) ) 随机值

&p是地址，p是指针变量，p存放的是常量字符串首元素’a‘的地址，但是p的地址与常量字符串没有关系，p的地址属于二级指针，一级指针的地址。所以是随机值。

6|printf (" %d\n ", sizeof ( &p+1 ) ) 4 / 8

&p+1是地址。所以大小为4个字节或者8个字节。

7|printf (" %d\n ", sizeof ( &p[0]+1 ) ) 4 / 8

&p[0]+1是地址。&p[0]就是‘a’的地址，+1就是‘b’的地址。

题目6：

char* p = "abcdef";
1|printf("%d\n",strlen(p));
2|printf("%d\n",strlen(p+1));
3|printf("%d\n",strlen(*p));
4|printf("%d\n",strlen(p[0]));
5|printf("%d\n",strlen(&p));
6|printf("%d\n",strlen(&p+1));
7|printf("%d\n",strlen(&p[0]+1));