计算机二级（C语言）考试高频考点总汇（二）—— 控制流、函数、数组和指针

目录

六、控制流

七、函数

八、数组和指针

六、控制流

76. if 语句可以（嵌套）， if 语句可以嵌套在另一个 if 语句内部，形成（嵌套的条件判断结构），用于处理更复杂的条件判断逻辑。

77. else if 语句用于处理（多个互斥条件）， else if 语句是 if 语句的（扩展），可以提供（多个备选的条件判断分支）。

78. switch 语句的 case 标签必须是（常量表达式）， case 标签的值必须是（唯一的），不能重复。（标签必须是整形）

79. switch 语句可以（没有default标签），如果 switch 语句没有 default 标签，并且没有一个 case 标签的值与 switch 表达式的值匹配，那么 switch 语句将（不执行任何操作）。

80. while 循环的条件在（每次迭代前检查），如果条件为真，则执行（循环体）；否则，跳出循

环。 while 循环可能（一次也不执行循环体）。

81. do...while 循环（至少执行一次代码块）， do...while 循环与 while 循环类似，但是do...while 循环的条件在（每次迭代后检查）。

82. for 循环的初始化、条件和更新表达式可以（省略），如果省略了初始化表达式，那么循环（不

会进行初始化操作）；如果省略了条件表达式，那么循环将（无限循环）。

83. 可以使用 break 语句跳出（多层嵌套循环）， break 语句只能跳出（当前循环），不能直接跳

出多层嵌套循环。

84. 可以使用 continue 语句跳过（当前循环迭代的剩余部分）， continue 语句（不会跳出循 环）。

85. goto 语句可以跳转到（同一函数内的任何标签位置）， goto 语句应该（谨慎使用），因为它

可能导致代码（难以理解和维护）。

七、函数

86. 函数可以（没有参数），表示该函数不需要接收任何输入数据，通常用于执行一些（独立的操

作）。

87. 函数可以（有多个参数），用于接收多个输入数据，参数之间用（逗号,）分隔，参数的类型和顺序必须与函数声明中的参数类型和顺序（一致）。

88. 函数参数可以是（任何数据类型），包括基本数据类型、结构体、共用体、指针等，参数的类型决定了函数可以接收的（数据种类）。

89. 函数参数传递可以是（值传递）或（地址传递），值传递是指将参数的值复制给函数，地址传递是指将参数的地址传递给函数。

90. 值传递是指将（参数的值复制给函数的形式参数），在函数内部对形式参数的修改（不会影响实际参数的值），可以保护实际参数的值不被修改。

91. 地址传递是指将（参数的地址传递给函数的形式参数），在函数内部对形式参数指向的内存空间进行修改（会影响实际参数的值），可以用于在函数内部修改实际参数的值。

92. 在函数内部修改（值传递的参数）不会影响原始变量，因为函数操作的是（参数的副本）。

93. 在函数内部修改（地址传递的参数）会影响原始变量，因为函数操作的是（原始变量的内存地

址）。

94. 函数可以返回（任何数据类型），包括基本数据类型、结构体、共用体、指针等，返回值的类型决定了函数可以返回的（数据种类）。

95. 函数可以使用（return语句）返回值， return 语句用于将函数的结果返回给（调用者），可以

出现在函数的（任何位置）。

八、数组和指针

96. 数组元素在内存中是（连续存储的），这意味着可以通过（指针运算）来访问数组元素。

97. 数组名是指向（数组第⼀个元素的指针），这意味着可以使用数组名来（访问数组元素）。

98. 可以使用（指针）访问数组元素，通过将指针指向数组的某个元素，然后使用指针运算来访问其他元素。

99. *(arr + i)等价于（arr[i]） ，都表示访问数组 arr 的第 i 个元素，前者是指针运算，后者是数组下标运算。

100. 指针可以进行（加减运算），用于在内存中移动指针的位置，指针加1表示指向（下一个相同类型的元素）。

101. 指针加1表示指向（下一个相同类型的元素），例如，如果 p 是一个指向 int 类型变量的指

针，那么 p + 1 将指向下一个 int 类型变量的内存地址。（移动sizeof（类型）个字节）

102. 指针减1表示指向（上一个相同类型的元素），例如，如果 p 是一个指向 int 类型变量的指

针，那么 p - 1 将指向上一个 int 类型变量的内存地址。

103. 可以使用（指针）遍历数组，通过将指针指向数组的第⼀个元素，然后使用指针运算来依次访问数组的每个元素。

104. 可以使用（指针作为函数参数）传递数组，通过将数组名作为参数传递给函数，函数可以访问和修改数组的元素。

105. 在函数内部修改（指针参数指向的数组元素）会影响原始数组，因为指针传递的是数组的（地址）。

106. 多维数组是（数组的数组），例如，二维数组可以看作是（行和列组成的表格）。

107. 多维数组元素在内存中也是（连续存储的），但其访问方式需要考虑（行和列的索引）。

108. 字符串是（字符数组），以（空字符 \0 ）结尾，空字符用于（标记字符串的结束）。

109. 字符串常量存储在（只读内存区域），程序（不能修改）字符串常量的内容。

110. 可以使用（strlen函数）获取字符串的长度， strlen 函数长度计数不包括（空字符 \0 ）。

111. 可以使用（strcpy函数）复制字符串， strcpy 函数会将源字符串的（空字符\0）也复制到目

标字符串。

112. 可以使用（strcat函数）连接字符串， strcat 函数会将源字符串连接到目标字符串的（末

尾），并添加（空字符\0）。

113. 可以使用（strcmp函数）比较字符串， strcmp 函数返回（0）表示两个字符串相等，返回

（正数）表示第一个字符串大于第二个字符串，返回（负数）表示第一个字符串小于第二个字符

串。

114. 可以使用（strstr函数）在一个字符串中查找子字符串， strstr 函数返回子字符串在字符串中

（第一次出现的位置的指针），返回（ NULL ）表示子字符串不存在。

115. 指针是一种（特殊的变量），用于（存储内存地址）。

116. 指针可以指向（任何数据类型），包括（基本数据类型）、（结构体）、（联合体）、（函数）等。

117. C语言中，指针是一个变量，存储的是（另一个变量的地址）。（通过指针可以间接访问和修改变量的值。指针是C语言中非常重要的概念，可以用于实现动态内存分配、函数参数传递等高级

特性。）

118. 定义一个指向整型变量的指针： int *p; 。（ * 表示 p 是一个指针变量， int 表示 p 指向的是整型变量。 p 可以存储任何整型变量的地址。）

• 示例：

int a = 10;
int *p; // 定义⼀个指向int的指针
p = &a; // 将a的地址赋值给p

119. 使用 & 运算符获取变量的（地址）。例如： p = &a; 。（ & 是取地址运算符，用于获取变量在内存中的地址。每个变量在内存中都有一个唯一的地址。）

• 示例：

int a = 10;
printf("变量a的地址是：%p\n", &a); // 输出a的地址，%p是⽤于输出指针的格式化字符

120. 使用 * 运算符访问指针指向的变量的（值）。例如： int b = *p; 。（ * 是解引用运算符，用于获取指针指向的变量的值。解引用指针可以访问和修改指针指向的变量。）

• 示例：

int a = 10;
int *p = &a;
printf("指针p指向的值是：%d\n", *p); // 输出p指向的值，即a的值
*p = 20; // 通过指针修改a的值
printf("变量a的值现在是：%d\n", a); // 输出a的值，现在是20

121. 指针可以进行算术运算，例如 p++ ，表示指针指向下一个内存单元。（指针的算术运算需要注意指针类型，不同类型的指针每次移动的字节数不同。例如， int 指针每次移动4个字节， char 指针每次移动1个字节。）

• 示例：

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr; // p指向数组的第⼀个元素
printf("第⼀个元素的值是：%d\n", *p);
p++; // p指向数组的第⼆个元素
printf("第⼆个元素的值是：%d\n", *p);

122. 数组名本质上是⼀个指向数组首元素的指针。（例如： int arr[5]; int *p = arr; p 指向arr[0]。这意味着可以使用指针来访问数组元素。）

• 示例：

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;
printf("数组的第⼀个元素是：%d\n", *arr); // 使⽤数组名访问第⼀个元素
printf("数组的第⼀个元素是：%d\n", *p); // 使⽤指针访问第⼀个元素

123. 可以使用指针遍历数组。（例如： for (int i = 0; i < 5; i++) { printf("%d", *(p + i)); } 。通过指针的算术运算，可以依次访问数组中的每个元素。）

• 示例：

int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;
for (int i = 0; i < 5; i++) 
{
    printf("数组的第%d个元素是：%d\n", i + 1, *(p + i));
}

124. 函数指针是指指向函数的指针。（函数指针可以用于实现回调函数等高级特性。函数指针可以存储函数的地址，并可以通过指针调用函数。）

125. 定义一个函数指针： int (*p)(int, int); ，表示p指向一个返回值为int，参数列表为 (int, int)的函数。（例如： p = add; p指向之前定义的add函数。函数指针的类型必须与指向的函数的类型匹配。）

• 示例：

int add(int a, int b) 
{
    return a + b;
}

int main() 
{
    int (*p)(int, int); // 定义⼀个函数指针
    p = add; // 将add函数的地址赋值给p
    int result = p(3, 5); // 通过函数指针调⽤add函数
    printf("3 + 5 = %d\n", result); // 输出结果
    return 0;
}

126. 可以使用函数指针调用函数。（例如： int result = p(3, 5); 。通过函数指针可以灵活地调用不同的函数，实现回调函数等高级特性。）

127. 指针可以作为函数的参数，用于传递变量的地址。（通过指针参数，函数可以修改外部变量的值。这是C语言中实现引用传递的方式。）

• 示例：

void swap(int *a, int *b) 
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() 
{
    int x = 10, y = 20;
    printf("交换前：x = %d, y = %d\n", x, y);
    swap(&x, &y); // 传递x和y的地址给swap函数
    printf("交换后：x = %d, y = %d\n", x, y);
    return 0;
}

128. 动态内存分配使用 malloc() 函数。（ malloc() 函数在 stdlib.h 头文件中定义，用于在堆上分配指定大小的内存空间，返回指向该内存空间的指针，如果分配失败则返回NULL。动态内存分配可以根据程序的需要动态地分配内存空间。）

• 示例：

#include <stdio.h>
#include <stdlib.h>
int main() 
{
    int *p = (int *)malloc(5 * sizeof(int)); // 分配5个int⼤⼩的内存空间
    if (p == NULL) 
    {
        printf("内存分配失败！\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) 
    {
        p[i] = i + 1; // 初始化数组
    }
    for (int i = 0; i < 5; i++) 
    {
        printf("%d ", p[i]); // 输出数组元素
    }
    printf("\n");
    free(p); // 释放内存空间
    return 0;
}

129. 动态分配的内存需要使用 free() 函数释放。（ free() 函数用于释放 malloc() 函数分配的内存空间，避免内存泄漏。如果不释放动态分配的内存，会导致程序占用越来越多的内存，最终导致程序崩溃。）

130. void * 指针是一种通用指针，可以指向任何类型的数据。（ void * 指针不能直接解引用，需要先转换为具体的指针类型。 void * 指针可以用于在不同的数据类型之间进行转换。）

• 示例：

#include <stdio.h>
#include <stdlib.h>
int main() 
{
    int a = 10;
    void *p = &a; // void指针可以指向任何类型的数据
    int *q = (int *)p; // 将void指针转换为int指针
    printf("a的值是：%d\n", *q); // 通过int指针访问a的值
    return 0;
}

131. （指针的本质是地址）：指针变量存储的是内存地址，通过它可以间接访问或修改该地址上存储的数据。（理解指针是理解C语言的关键。例如， int *p = &a; 表示指针 p 存储了变量a 的内存地址。）

• 示例：

#include <stdio.h>
int main() 
{
    int a = 10;
    int *p = &a; // p 存储了 a 的地址
    printf("a 的值: %d\n", a);
    printf("p 指向的值: %d\n", *p); // 通过 p 访问 a 的值
    *p = 20; // 通过 p 修改 a 的值
    printf("a 的新值: %d\n", a);
    return 0;
}

132. （多级指针用于管理指针的地址）：多级指针是指指向指针的指针，常用于动态创建多维数组或处理复杂数据结构。（例如， int **p; 表示 p 是一个指向 int* 类型变量的指针，可以用来管理动态分配的二维数组。）

• 示例： 动态分配二维数组

#include <stdio.h>
#include <stdlib.h>
int main() 
{
    int **arr;
    int rows = 3, cols = 4;
    int i, j;
    // 分配⾏指针空间
    arr = (int **)malloc(rows * sizeof(int *));
    for (i = 0; i < rows; i++) 
    {
        arr[i] = (int *)malloc(cols * sizeof(int));
    }
    // 初始化数组
    for (i = 0; i < rows; i++) 
    {
        for (j = 0; j < cols; j++) 
        {
            arr[i][j] = i * cols + j;
        }
    }
    // 打印数组
    for (i = 0; i < rows; i++) 
    {
        for (j = 0; j < cols; j++) 
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
    // 释放内存
    for (i = 0; i < rows; i++) 
    {
        free(arr[i]);
    }
    free(arr);
    return 0;
}

133. （指针数组是存储指针的数组）：指针数组的每个元素都是一个指针，常用于存储字符串或管理多个动态分配的内存块。（例如， char *str[] = {"hello", "world"}; 定义了一个字符串指针数组， str[0] 指向 "hello" 字符串的首地址。）

• 示例： 存储字符串数组

#include <stdio.h>
int main() 
{
    char *str[] = {"hello", "world", "!"};
    int i;
    for (i = 0; i < 3; i++) 
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

134. （函数指针指向函数的入口地址）：函数指针可以存储函数的地址，并通过该指针调用函数，实现回调函数和动态函数调用。（例如， int (*func)(int, int); 定义了⼀个函数指针，可以指向接受两个 int 参数并返回 int 值的函数。）

• 示例：

#include <stdio.h>
int add(int a, int b) 
{
    return a + b;
}

int main() 
{
    int (*func)(int, int) = add; // 函数指针指向 add 函数
    int result = func(5, 3); // 通过函数指针调⽤ add 函数
    printf("Result: %d\n", result);
    return 0;
}

135. （函数指针数组用于存储多个函数指针）：函数指针数组是一个数组，其每个元素都是⼀个函数指针，常用于实现命令分发器或状态机。（例如， int (*operations[])(int, int) = {add, subtract}; 定义了一个函数指针数组，可以根据索引调用不同的函数。）

• 示例：

#include <stdio.h>
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }

int main() 
{
    int (*operations[])(int, int) = {add, subtract};
    int choice = 0; // 0: add, 1: subtract
    int result;
    result = operations[choice](10, 5);
    printf("Result: %d\n", result);
    return 0;
}

136. （ void 指针是通用指针，可以指向任何类型的数据）： void 指针可以指向任何数据类型，但在使用时需要强制类型转换。（例如， void *p; int a = 10; p = &a; int *q = (int *)p; void 指针 p 指向 int 类型的变量 a ，需要先转换为 int * 类型才能通过 *q 访问 a 的值。）

• 示例：

#include <stdio.h>
int main() 
{
    int a = 10;
    void *p = &a; // void 指针指向 int 类型变量
    int *q = (int *)p; // 强制类型转换
    printf("Value: %d\n", *q);
    return 0;
}

137. （指针的算术运算与指针类型相关）：指针的加减运算会根据指针所指向的数据类型的大小进行调整。（例如， int *p; p++; p 的值会增加 sizeof(int) 个字节，即 4 个字节。）

• 示例：

#include <stdio.h>
int main() 
{
    int arr[] = {1, 2, 3, 4, 5};
    int *p = arr; // p 指向数组⾸元素
    printf("第⼀个元素: %d\n", *p);
    p++; // p 指向下⼀个元素
    printf("第⼆个元素: %d\n", *p);
    return 0;
}

138. （指针与数组名的关系）：数组名在大多数情况下可以看作是指向数组首元素的指针，但数组名不是指针变量，不能进行赋值操作。（例如， int arr[10]; int *p = arr; p 指向数组 arr 的首元素，但 arr = p; 是非法的。）

• 示例：

#include <stdio.h>
int main() 
{
    int arr[] = {1, 2, 3};
    int *p = arr;
    printf("第⼀个元素: %d\n", *arr); // 通过数组名访问
    printf("第⼀个元素: %d\n", *p); // 通过指针访问
    return 0;
}

139. （const 指针用于限制指针的修改权限）： const 关键字可以用于限制指针本身或指针所指向

的数据的修改权限。（例如， const int *p; 表示指针 p 指向的数据是常量，不能通过p 修改数据的值； int * const p; 表示指针 p 本身是常量，不能修改 p 的指向。）

• 示例：

#include <stdio.h>
int main() 
{
    int a = 10;
    const int *p = &a; // 不能通过 p 修改 a 的值
    // *p = 20; // 错误: assignment of read-only location *p
    a = 20; // 正确: 可以直接修改 a 的值
    printf("Value: %d\n", a);
    int *const q = &a; // q 指针本⾝不能修改指向
    *q = 30; // 正确: 可以通过 q 修改 a 的值
    // q = &a; // 错误: assignment to read-only variable q
    return 0;
}

140. （动态内存分配需要手动释放，避免内存泄漏）：使用 malloc 、 calloc 等函数动态分配的内存，需要使用 free 函数手动释放，否则会导致内存泄漏。（例如， int *p = (int*)malloc(100 * sizeof(int)); free(p); 分配了 100 个 int 类型的空间，使用完毕后需要调用 free(p) 释放内存。）

malloc和calloc函数分配的内存类型都为void*类型。

• 示例：

#include <stdio.h>
#include <stdlib.h>
int main() 
{
    int *p = (int *)malloc(100 * sizeof(int));
    if (p == NULL) 
    {
        printf("内存分配失败\n");
        return 1;
    }
    // 使⽤ p
    free(p); // 释放内存
    p = NULL; // 防⽌悬挂指针
    return 0;
}