C语言指针笔试题解析：从基础概念到内存管理实战

C语言指针指针笔试题内存管理

于 2026-07-31 04:25:11 修改

·本内容遵循CC 4.0 BY-SA版权协议

这次我们来看一些有趣的C语言指针笔试题。指针作为C语言的核心概念，一直是面试和笔试中的重点考察内容。通过实际的题目练习，不仅能检验对指针的理解程度，还能加深对内存管理的认识。

下面我将分享几道经典的指针笔试题，每道题都配有详细的解析和内存示意图。无论你是准备面试还是想巩固C语言基础，这些题目都值得一试。

1. 指针基础概念回顾

在开始做题之前，我们先快速回顾几个关键的指针概念：

概念	说明	示例
指针定义	存储变量地址的变量	`int *p;`
取地址运算符	获取变量的内存地址	`&a`
解引用运算符	通过指针访问指向的值	`*p`
指针运算	指针加减整数时的地址变化	`p+1` 移动sizeof(类型)字节

理解这些基础概念是正确解答指针题目的前提。

2. 题目一：基本指针操作

# include <stdio.h>

int main() {

int a = 10;

int b = 20;

int *p = &a;

int *q = &b;

*p = 30;

*q = *p + 10;

p = q;

*p = 50;

printf("a = %d, b = %d\n", a, b);

return 0;

}

2.1 逐步分析

让我们一步步跟踪程序的执行过程：

int a = 10; int b = 20;
- 在内存中分配两个整型变量，a的值为10，b的值为20
int *p = &a; int *q = &b;
- p指向a的地址，q指向b的地址
*p = 30;
- 通过p修改a的值为30
*q = *p + 10;
- 通过q修改b的值为30+10=40
p = q;
- 让p也指向b的地址（现在p和q都指向b）
*p = 50;
- 通过p修改b的值为50

2.2 内存变化示意图

TEXT

初始状态：

a[10] b[20]

^ ^

| |

p q

执行*p=30后：

a[30] b[20]

^ ^

| |

p q

执行*q=*p+10后：

a[30] b[40]

^ ^

| |

p q

执行p=q后：

a[30] b[40]

^ ^

| |

p q

执行*p=50后：

a[30] b[50]

^ ^

| |

p q

2.3 最终输出结果

根据分析，程序最终输出：a = 30, b = 50

3. 题目二：指针与数组

# include <stdio.h>

int main() {

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

int *p = arr;

printf("%d ", *p++);

printf("%d ", (*p)++);

printf("%d ", *++p);

printf("%d ", ++*p);

printf("\n数组内容：");

for(int i = 0; i < 5; i++) {

printf("%d ", arr[i]);

}

return 0;

}

3.1 运算符优先级分析

这道题考察的是指针运算和运算符优先级的理解：

*p++：先取p指向的值，然后p自增（后缀++优先级高于*，但后缀++先用后加）
(*p)++：先取p指向的值，然后该值自增
*++p：先p自增，然后取p指向的值（前缀++与*优先级相同，从右向左结合）
++*p：先取p指向的值，然后该值自增1

3.2 逐步执行过程

初始状态：arr = {1, 2, 3, 4, 5}, p指向arr[0]

printf("%d ", *p++);
- 输出arr[0]的值1，然后p指向arr[1]
- 当前输出：1
printf("%d ", (*p)++);
- 输出arr[1]的值2，然后arr[1]自增为3
- 当前输出：1 2
printf("%d ", *++p);
- p先自增指向arr[2]，然后输出arr[2]的值3
- 当前输出：1 2 3
printf("%d ", ++*p);
- arr[2]的值自增为4，然后输出4
- 当前输出：1 2 3 4

3.3 最终数组状态

经过上述操作后，数组内容变为：{1, 3, 4, 4, 5}

4. 题目三：多级指针

# include <stdio.h>

int main() {

int a = 100;

int *p = &a;

int **pp = &p;

int ***ppp = &pp;

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

printf("*p = %d\n", *p);

printf("**pp = %d\n", **pp);

printf("***ppp = %d\n", ***ppp);

***ppp = 200;

printf("修改后 a = %d\n", a);

return 0;

}

4.1 多级指针的内存模型

TEXT

a[100] <-- p <-- pp <-- ppp

(整型变量) (一级指针) (二级指针) (三级指针)

p存储a的地址
pp存储p的地址
ppp存储pp的地址

4.2 解引用过程分析

*p：从p中取出a的地址，然后访问该地址的值
**pp：先从pp中取出p的地址，然后从p中取出a的地址，最后访问a的值
***ppp：三级解引用，最终访问a的值

4.3 输出结果

TEXT

a = 100

*p = 100

**pp = 100

***ppp = 100

修改后 a = 200

通过多级指针可以修改原始变量的值，这在函数参数传递中特别有用。

5. 题目四：指针与字符串

# include <stdio.h>

# include <string.h>

int main() {

char str1[] = "Hello";

char str2[] = "World";

char *p1 = str1;

char *p2 = str2;

// 字符串连接操作

while(*p1) p1++;

while(*p2) {

*p1 = *p2;

p1++;

p2++;

}

*p1 = '\0';

printf("连接后的字符串: %s\n", str1);

printf("str1长度: %lu\n", strlen(str1));

return 0;

}

5.1 代码功能分析

这个程序实现了字符串连接功能，类似于strcat函数：

首先让p1移动到str1的末尾（遇到'\0'停止）
然后将str2的内容逐个字符复制到str1末尾
最后添加字符串结束符'\0'

5.2 内存安全考虑

这种实现方式存在缓冲区溢出风险，因为str1的数组大小可能不足以容纳连接后的字符串。在实际编程中应该使用更安全的方法：

// 安全的方式：检查目标缓冲区大小

char str1[20] = "Hello"; // 确保有足够空间

char str2[] = "World";

strncat(str1, str2, sizeof(str1) - strlen(str1) - 1);

5.3 输出结果

TEXT

连接后的字符串: HelloWorld

str1长度: 10

6. 题目五：函数指针应用

# include <stdio.h>

int add(int a, int b) {

return a + b;

}

int subtract(int a, int b) {

return a - b;

}

int calculate(int (*operation)(int, int), int x, int y) {

return operation(x, y);

}

int main() {

int a = 15, b = 7;

int result1 = calculate(add, a, b);

int result2 = calculate(subtract, a, b);

printf("%d + %d = %d\n", a, b, result1);

printf("%d - %d = %d\n", a, b, result2);

// 函数指针数组示例

int (*funcs[2])(int, int) = {add, subtract};

for(int i = 0; i < 2; i++) {

printf("结果%d: %d\n", i+1, funcs[i](a, b));

}

return 0;

}

6.1 函数指针语法解析

int (*operation)(int, int)

*operation：operation是一个指针
(*operation)(int, int)：该指针指向一个函数，函数接受两个int参数
int (*operation)(int, int)：函数返回int类型

6.2 函数指针的应用场景

回调函数：将函数作为参数传递
策略模式：运行时选择不同的算法
插件系统：动态加载和执行函数
命令模式：将操作封装为函数指针

6.3 输出结果

TEXT

15 + 7 = 22

15 - 7 = 8

结果1: 22

结果2: 8

7. 题目六：结构体指针

# include <stdio.h>

# include <stdlib.h>

# include <string.h>

typedef struct {

char name[20];

int age;

float score;

} Student;

void printStudent(Student *s) {

printf("姓名: %s, 年龄: %d, 分数: %.1f\n",

s->name, s->age, s->score);

}

void initStudent(Student *s, const char *name, int age, float score) {

strncpy(s->name, name, sizeof(s->name) - 1);

s->name[sizeof(s->name) - 1] = '\0';

s->age = age;

s->score = score;

}

int main() {

Student stu1;

Student *pStu = &stu1;

initStudent(pStu, "张三", 20, 85.5);

printStudent(pStu);

// 动态分配结构体

Student *dynamicStu = (Student*)malloc(sizeof(Student));

if(dynamicStu != NULL) {

initStudent(dynamicStu, "李四", 22, 92.0);

printStudent(dynamicStu);

free(dynamicStu);

}

return 0;

}

7.1 结构体指针操作符

s->name：等价于 (*s).name
箭头操作符更简洁，直接通过指针访问结构体成员

7.2 内存管理要点

栈分配：Student stu1; 自动管理内存
堆分配：malloc(sizeof(Student)) 需要手动管理
字符串安全：使用strncpy避免缓冲区溢出

7.3 输出结果

TEXT

姓名: 张三, 年龄: 20, 分数: 85.5

姓名: 李四, 年龄: 22, 分数: 92.0

8. 常见指针错误与排查方法

错误类型	现象	原因	解决方法
空指针解引用	程序崩溃	对NULL指针进行解引用	使用前检查指针是否为NULL
野指针	不可预测行为	指针指向已释放的内存	释放后立即置为NULL
缓冲区溢出	内存破坏	写入超出分配空间的数据	使用安全函数，检查边界
内存泄漏	内存持续增长	分配的内存未释放	确保malloc/free成对使用
类型不匹配	编译警告/错误	指针类型与目标类型不匹配	使用正确的指针类型

8.1 调试技巧

// 使用断言检查指针有效性

# include <assert.h>

void safeFunction(int *ptr) {

assert(ptr != NULL);

// 安全使用ptr

}

// 使用调试宏

# ifdef DEBUG

# define CHECK_PTR(ptr) \

if(ptr == NULL) { \

printf("空指针错误: %s, 行号: %d\n", __FILE__, __LINE__); \

return; \

}

# else

# define CHECK_PTR(ptr)

# endif

9. 指针编程最佳实践

9.1 防御性编程

// 好的实践：全面的错误检查

int *createIntArray(size_t size) {

if(size == 0) {

return NULL;

}

int *arr = (int*)malloc(size * sizeof(int));

if(arr == NULL) {

perror("内存分配失败");

return NULL;

}

// 初始化内存

memset(arr, 0, size * sizeof(int));

return arr;

}

// 使用示例

int *data = createIntArray(10);

if(data != NULL) {

// 安全使用data

free(data);

data = NULL; // 避免野指针

}

9.2 代码可读性建议

命名规范：指针变量以p开头，如pStudent、pArray
注释说明：复杂指针操作添加注释
模块化：将指针操作封装成函数
资源管理：谁分配谁释放的原则

10. 进阶练习建议

掌握了基础指针题目后，可以尝试以下进阶内容：

函数指针高级应用：实现排序算法的回调接口
多级指针实战：动态二维数组的创建和释放
指针与链表：实现各种链表数据结构
内存池设计：自定义内存管理机制
智能指针模拟：用C实现引用计数

通过不断练习和实际项目应用，能够真正掌握指针这一强大的C语言特性。建议在编写涉及指针的代码时，始终关注内存安全和代码可维护性，养成良好的编程习惯。