Linux操作系统与IO编程拟面试题

一、指令部分

具体指令及其用法

二、Linux路径下内容

三、硬软连接区别

1. 硬链接

创建方式：ln 原文件 硬链接名（默认不带 -s）

特点： 所有硬链接地位平等，没有 “主文件 / 副本” 之分，删除任意一个都不影响其他链接。 只有当所有硬链接都被删除，且没有进程打开文件时，文件数据才会被系统回收。 无法跨文件系统创建，也不能链接目录（普通用户）。

2. 软连接

创建方式：ln -s 原文件/目录 软连接名（必须带 -s 参数）

特点： 是独立的文件，存储的是目标的路径信息，删除软连接不会影响原文件。

原文件被移动、重命名或删除后，软连接会失效，变成红色的 “死链接”。

支持跨分区、跨文件系统，也可以链接目录，使用更灵活。

一句话总结

硬链接：文件的 “别名”，共享数据块，防误删，不能跨分区 / 链接目录。

软连接：文件的 “快捷方式”，记录路径，可跨分区 / 链接目录，原文件删除后失效。

四、环境变量的配置

1.临时配置（仅当前终端有效）

如果你只是临时想测试一下某个路径，或者不想修改系统文件，可以使用 export 命令。
命令格式：export 变量名=变量值
示例（添加 PATH）：

export PATH=$PATH:/opt/my_new_tool/bin export 声明为全局环境变量，子进程、终端都能生效 PATH 系统命令查找路径变量 = 赋值 $PATH $\ = 引用变量 👉 保留**原来所有的旧路径 **，不覆盖 : Linux 路径分隔符，用来隔开多个路径 /opt/my_new_tool/bin 你要新增的自定义命令路径 把 /opt/my_new_tool/bin 追加到 原有 PATH 后面 ✅ 不会删掉系统原本的命令路径 ✅ 以后可以直接执行这个目录里的程序，不用 ./

（注意：$PATH 表示保留原本的路径，后面追加新的路径。如果直接写 PATH=/xxx，原本的系统命令（如 ls, cd）可能会找不到）

生效范围：只在当前 Shell 会话中有效，关闭终端或重启后失效。

2.永久配置

永久配置（写入配置文件） 要让环境变量永久生效，需要将 export 命令写入到特定的配置文件中。

根据作用范围不同，分为用户级和系统级。

用户级配置（推荐） 适用场景：只针对当前登录的用户生效，不影响其他用户。 常用文件：~/.bashrc 或 ~/.profile（最常用的是 ~/.bashrc）。

操作步骤：

(1)打开文件：vim ~/.bashrc

(2)在文件末尾添加：

export MY_VAR="hello" export PATH=$PATH:/your/custom/path

(3)保存退出。
(4)立即生效：执行 source ~/.bashrc。

3.系统级配置（全局）

适用场景：对所有用户都生效（需要 root 权限）。
常用文件：/etc/profile 或 /etc/environment。
操作步骤：
（1）打开文件：sudo vim /etc/profile
（2）在文件末尾添加：

export JAVA_HOME=/usr/local/java export PATH=$PATH:$JAVA_HOME/bin

（3）保存退出。
(4)立即生效：执行 source /etc/profile。

4.环境变量的作用

1、指定系统或软件配置
2、告诉程序去找依赖
3、传递敏感信息
4、C语言编译参数

5.常见的环境变量及用途

验证配置是否成功
配置完成后，可以使用以下命令查看变量是否已生效：
查看特定变量：

echo $PATH echo $JAVA_HOME

查看所有

env

五、makefile

1.Makefile 是什么？

Makefile 是GNU Make 工具的配置文件，用来自动化编译项目。

核心解决什么问题？

项目文件多、依赖复杂，手动敲 gcc 命令容易出错、效率低
自动判断：哪些文件被修改过，只重新编译修改过的文件，大幅提升编译效率
一键执行编译、清理、安装等操作，不用记复杂命令

2.Makefile 最基础语法（万能模板）

目标: 依赖文件列表 命令1 命令2

⚠️ 关键细节：命令前面必须是一个 Tab 键，不能用空格！
核心概念
目标（target）：要生成的文件（比如可执行文件、.o 文件），也可以是伪目标（比如 clean）
依赖（prerequisites）：生成目标需要的文件 / 条件
命令（recipe）：依赖更新后，执行的编译 / 操作命令

# 最终目标：生成可执行文件 calc # 依赖：三个 .o 目标文件（必须先生成这三个） calc: main.o add.o sub.o gcc main.o add.o sub.o -o calc # 把三个 .o 链接成可执行文件 calc # 目标：生成 main.o # 依赖：main.c + add.h + sub.h（头文件变了也要重新编译） main.o: main.c add.h sub.h gcc -c main.c -o main.o # -c：只编译，不链接，生成 main.o # 目标：生成 add.o # 依赖：add.c + add.h add.o: add.c add.h gcc -c add.c -o add.o # -c：只编译，生成 add.o #当 add.c 或 add.h 发生变化时，执行 gcc -c add.c -o add.o，重新生成 add.o 目标文件 # 目标：生成 sub.o # 依赖：sub.c + sub.h sub.o: sub.c sub.h gcc -c sub.c -o sub.o # -c：只编译，生成 sub.o # 伪目标：清理编译产生的文件 clean: rm -rf *.o calc # 删除所有 .o 文件 + 可执行文件 calc

3.Makefile 核心符号详解

1. $<：第一个依赖文件

# 模式规则：所有 .o 文件都由对应的 .c 文件生成 %.o: %.c # $< 代表第一个依赖文件，这里就是 %.c gcc -c $< -o $@

当处理 main.o 时，$< 会自动替换成 main.c
等价于：gcc -c main.c -o main.o

2. $@：当前目标文件

# 最终目标：生成 calc calc: main.o add.o sub.o # $@ 代表当前目标文件，这里就是 calc gcc main.o add.o sub.o -o $@

等价于：gcc main.o add.o sub.o -o calc

# 也可以用在模式规则里 %.o: %.c gcc -c $< -o $@

处理 main.o 时，$@ 就是 main.o

3. $^：所有依赖文件（去重）

calc: main.o add.o sub.o # $^ 代表所有依赖文件：main.o add.o sub.o（自动去重） gcc $^ -o $@

等价于：gcc main.o add.o sub.o -o calc
如果依赖里有重复的文件，$^ 会自动去掉重复项，只保留一份

4. $*：不包含扩展名的目标文件名

# 比如目标是 main.o，$* 就是 main %.o: %.c gcc -c $< -o $@ # $* 可以用来生成不带扩展名的中间文件 echo "编译了 $*.c，生成了 $*.o"

运行 make main.o 时，会输出：编译了 main.c，生成了 main.o

5. @：执行命令时不打印命令本身

clean: # 不加 @：终端会打印 rm -rf *.o calc rm -rf *.o calc # 加 @：只打印“清理完成”，不打印 echo 命令 @echo "清理完成"

效果对比：
不加 @：终端会显示 echo "清理完成"，再显示文字
加 @：终端只显示 清理完成，不会显示 echo 命令本身

6.%：通配符，用于模式匹配

# 模式规则：所有 .o 文件，都由同名的 .c 文件生成 %.o: %.c gcc -c $< -o $@

这里的 %.o 和 %.c 是一对通配符
当你执行 make main.o 时，Make 会自动匹配 main.c，并执行规则里的命令
不用再一个个写 main.o: main.c、add.o: add.c 了

7.完整示例

# 编译器 CC = gcc # 编译选项 CFLAGS = -Wall -g # 目标文件列表 OBJS = main.o add.o sub.o # 最终可执行文件 TARGET = calc # 最终目标：链接所有 .o 文件 $(TARGET): $(OBJS) # $^：所有依赖文件；$@：当前目标文件 $(CC) $^ -o $@ # @：不打印 echo 命令本身 @echo "链接完成，生成可执行文件：$@" # 模式规则：自动编译所有 .c 文件为 .o 文件 %.o: %.c # $<：第一个依赖文件；$@：当前目标文件 $(CC) $(CFLAGS) -c $< -o $@ @echo "编译完成：$*.c → $*.o" # 伪目标：清理 .PHONY: clean clean: rm -rf $(OBJS) $(TARGET) @echo "清理完成"

运行结果

1.执行 make：
会自动编译 main.c add.c sub.c 为 .o 文件
再链接生成 calc
终端只会显示 编译完成：main.c → main.o 这类信息，不会打印 gcc 命令本身
2.执行 make clean：
会删除所有 .o 文件和 calc，并打印 清理完成

4.伪目标（.PHONY）详解

伪目标不是一个真实的文件，只是一个操作命令的名字，比如 clean、install。
为什么要加 .PHONY？

如果当前目录下有一个叫 clean 的文件，make clean 会认为目标文件已经存在且无需更新，就不会执行 clean 里的命令。
用 .PHONY: clean 声明后，Make 就会把它当成伪目标，不管有没有同名文件，都会执行命令。

5.Makefile 工作流程（理解它的核心逻辑）

a.执行 make 时，默认找第一个目标（比如 calc）
b.检查 calc 的依赖文件（main.o add.o sub.o）是否存在、是否被修改过
c.递归检查每个依赖的依赖（比如 main.o 依赖 main.c add.h）
d.如果 .c 文件比 .o 文件新，就重新编译生成 .o
e.所有 .o 文件更新完成后，执行链接命令生成最终目标

6.极简背诵版

核心格式：目标: 依赖，命令前必须是 Tab
变量用 = 定义，$(变量名) 引用
模式规则 %.o: %.c，配合 $< $@ 简化代码
伪目标用 .PHONY 声明，避免和文件重名
make 只编译修改过的文件，提升效率

六、GDB调试流程

*编译生成带调试信息的可执行文件： gcc -g 源文件.c -o 可执行文件 （例：gcc -g main.c -o main） 启动gdb调试程序： gdb 可执行文件名 （例：gdb main） 常用调试操作： l 查看源码 b 行号 设置断点 r 运行程序 n 单步跳过 s 单步进入 p 变量名 打印变量 c 继续运行 q 退出gdb

gcc -g开启调试
r：继续运行
b：打断点
n：单步跳过
s：单步进入
bt：查看程序栈
p：看变量的值

gcc 是什么？
GNU C Compiler → C 语言编译器
作用：把 .c 源代码 → 变成 可执行文件

gcc 文件名.c → 生成 a.out
-o 名字 → 指定可执行文件名
-c → 只编译，生成 .o
-g → 加调试信息，给 gdb 用

七、标准IO的缓存机制和刷新条件

缓冲机制

1. 全缓冲（Full Buffering）默认4096字节（4KB）
规则：只有当缓冲区被写满，或调用fflush强制刷新时，数据才会写入内核。
适用场景：文件流（fopen打开的文件，默认全缓冲）。
特点：效率最高，系统调用次数最少。

2. 行缓冲（Line Buffering）默认1024字节（1KB）
规则：遇到换行符\n、缓冲区写满、调用fflush或程序正常退出时，数据会被刷新。
适用场景：标准输入stdin、标准输出stdout（终端设备默认行缓冲）
例子：printf("hello");不会立即输出，直到遇到\n或程序结束。

3. 无缓冲（Unbuffered）默认0字节
规则：数据不经过用户缓冲区，直接调用系统调用写入内核。
适用场景：标准错误stderr（默认无缓冲，错误信息会立即输出，方便调试）
特点：效率最低，但实时性最强，错误信息不会被缓冲延迟。

缓存区刷新条件

1.缓冲区写满
2.调用 fflush(fp) 强制刷新
3.程序正常结束
4.调用 fclose(fp) 关闭文件
5.终端流遇到换行符

6.遇到换行符'\n'（仅行缓冲中）

八、动静态库的区别

九、标准IO创建文件的权限用文件IO创建如何编写

1.标准IO（fopen)

没有权限参数，创建文件默认权限：0666，受 umask 修正。

// w 模式：不存在则创建，存在则清空 FILE *fp = fopen("test.txt", "w");

2.文件 IO（open）：

必须在 O_CREAT 时指定 mode 参数，实际权限 = mode & ~umask

open("test.txt", O_RDWR | O_CREAT | O_TRUNC, 0664);

#include <stdio.h> int main() { // 不存在就创建，存在就清空 FILE *fp = fopen("test.txt", "w"); if(NULL == fp) { perror("fopen"); return -1; } fclose(fp); return 0; }

#include <stdio.h> #include <unistd.h> #include <fcntl.h> int main() { // 和 fopen "w" 完全等价 // O_WRONLY ：只写 // O_CREAT ：文件不存在则创建 // O_TRUNC ：文件存在则清空 // 0666 ：创建默认权限 int fd = open("test.txt", O_WRONLY|O_CREAT|O_TRUNC, 0666); if(-1 == fd) { perror("open"); return -1; } close(fd); return 0; }

十、IO实现拷贝（文件和标准IO）

1.文件IO实现拷贝

#include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> int main(int argc, const char *argv[]) { // 1.对输入参数的参数个数进行检查 argc if (argc != 3) { printf("输入的参数个数有误\n"); printf("usage: ./a.out src_file dest_file\n"); return -1; } // 2.以只读的方式打开源文件 以只写的方式打开目标文件 open // argv[1] 源文件的路径 // argv[2] 目标文件的路径 int src_fd = 0; //源文件的文件描述符 //O_RDONLY如果文件不存在则会进行报错,打开文件就会失败 if(-1 == (src_fd = open(argv[1],O_RDONLY))) { perror("打开源文件失败"); return -1; } printf("打开源文件成功,src_fd=%d\n",src_fd); int dest_fd = 0; //目标文件的文件描述符 //O_WRONLY如果文件不存在则会进行报错.打开文件失败 //以只写的方式打开文件,如果文件不存在则创建新文件 //如果文件存在则将文件中原有的内容进行清空操作 if(-1 == (dest_fd = open(argv[2],O_WRONLY|O_CREAT|O_TRUNC,0666))) { perror("打开目标文件失败"); return -1; } printf("打开目标文件成功,dest_fd=%d\n",dest_fd); // 3.循环读取和写入 read 和 write char buf[1024] = {0}; ssize_t ret_read = 0; //用来接收read函数的返回值 ssize_t ret_write = 0; //用来接收write函数的返回值 while((ret_read = read(src_fd,buf,sizeof(buf)))>0) { //循环写入操作 ret_write = write(dest_fd,buf,ret_read); if(ret_write == -1) { perror("写入目标文件失败"); return -1; } //检查写入的字节数与读取的字节数是否一致 if(ret_read != ret_write) { printf("写入的字节数与读取的字节数不一致\n"); return -1; } } // 4.关闭文件 close close(src_fd); close(dest_fd); return 0; }

2.标准IO实现拷贝

#include <stdio.h> #define BUF_SIZE 1024 // 缓冲区大小 int main(int argc, const char *argv[]) { // 参数校验：./a.out 源文件 目标文件 if (argc != 3) { printf("参数错误！\n"); printf("用法：%s src_file dest_file\n", argv[0]); return 1; } FILE *fp_src = fopen(argv[1], "r"); FILE *fp_dest = fopen(argv[2], "w"); if (fp_src == NULL || fp_dest == NULL) { perror("文件打开失败"); return 1; } char buf[BUF_SIZE] = {0}; size_t ret; // 循环块读取 + 块写入 while ((ret = fread(buf, 1, BUF_SIZE, fp_src)) > 0) { // 只写入实际读到的字节数 fwrite(buf, 1, ret, fp_dest); } // 关闭流 fclose(fp_src); fclose(fp_dest); printf("文件拷贝完成\n"); return 0; }

十一、标准IO和文件IO的区别

文件 IO：Linux 系统调用，无用户态缓冲区，直接操作内核
标准 IO：C 标准库函数，带用户态缓冲区，效率更高，跨平台

十二、段错误一般由什么情况引起

访问非法内存：访问操作系统禁止读写的内存地址，如内核空间、未分配内存。

野指针、空指针操作：指针未初始化、指针为 NULL，直接解引用、赋值、读写。

数组越界：访问数组下标超出定义范围，破坏栈内存。

修改只读内存：例如：字符串常量不可修改，char *p="abc"; p[0]='1';

栈溢出：局部数组过大、递归层数过多，耗尽栈空间。

重复释放 / 多次 free：同一块堆内存重复释放，破坏内存管理结构。

释放后继续使用内存：free 销毁空间后，继续操作该指针。

总结：空指针 / 野指针解引用、数组越界、修改常量字符串、栈溢出、非法访问内存、重复释放内存、释放后继续使用。

缓冲区的区别（最容易考）
文件 IO：每次 read/write 都直接发起系统调用，频繁读写会非常慢
标准 IO：数据先写到用户态缓冲区，缓冲区满 / 刷新时才一次性调用系统写入内核，大大减少系统调用次数

对应关系：

用 标准 IO：写日志、配置文件、普通文本处理（带缓存，效率高）
用 文件 IO：设备驱动、网络套接字、实时数据传输（无缓存，直接操作）

stdin、stdout、stderr

1. 含义
stdin 标准输入 键盘
stdout 标准输出 终端屏幕
stderr 标准错误 终端屏幕
2. 文件描述符（文件 IO）
0 → 标准输入 stdin
1 → 标准输出 stdout
2 → 标准错误 stderr

3.标准IO对应

FILE *stdin; FILE *stdout; FILE *stderr;

4.例子

// 往标准输出打印 fprintf(stdout,"hello\n"); // 往标准错误打印 fprintf(stderr,"出错了！\n");

软硬链接什么时候用：

1.硬链接：什么时候用？
✅ 场景 1：需要多个文件名指向同一个文件，且不希望文件被误删
比如：你有一个重要配置文件，想在多个地方都能访问，又怕不小心删了其中一个导致文件丢失。
用法：

ln /etc/nginx/nginx.conf /home/user/nginx.conf.link

效果：删 /home/user/nginx.conf.link，原文件 /etc/nginx/nginx.conf 完全不受影响。

场景 2：做文件备份 / 防误删（同分区内）
原理：硬链接本质是同一个文件，修改任何一个链接，所有链接都会同步变化。
比如：重要日志文件，建一个硬链接，就算原文件被程序删除（inode 计数没到 0，进程还开着），硬链接依然能看到完整数据。

2.❌ 硬链接绝对不能用的情况
跨不同磁盘 / 分区（比如把 /home 下的文件链接到 /tmp 下）
链接目录（系统默认不允许，防止循环链接）
链接不存在的文件（硬链接必须基于已存在的 inode）

3.软链接：什么时候用？（日常开发 90% 的场景都用它）
✅ 场景 1：简化路径，快速访问深层目录 / 文件
比如：你经常要进 /opt/software/nginx-1.24.0/conf/，每次输路径太麻烦。
用法：

ln -s /opt/software/nginx-1.24.0/conf/ ~/nginx-conf

效果：直接 cd ~/nginx-conf 就能进去，不用输长路径。

✅ 场景 2：软件版本切换（比如 Python、JDK）
比如：你同时装了 Python3.8 和 Python3.10，想随时切换默认版本。
用法：

ln -s /usr/bin/python3.10 /usr/bin/python

想切回 3.8 时，删掉旧链接重新建就行，不用改环境变量。
✅ 场景 3：跨分区 / 跨磁盘链接文件
比如：你在系统盘装了程序，数据存在数据盘，用软链接把数据盘的目录链接到程序的默认路径下。
硬链接做不到，但软链接可以。
✅ 场景 4：给编译后的可执行文件创建快捷方式
比如：你自己编译了一个 myapp，想直接在终端输入 myapp 就能运行，不用写 ./myapp 或者绝对路径。
用法：

ln -s /home/user/myapp/bin/myapp /usr/local/bin/myapp

软链接的坑：原文件 / 目录删除 / 移动后，链接会失效
比如：你把原文件 nginx.conf 删了，软链接就变成了无效的 “红名文件”，打开会报错。

怎么选？
同分区、想防误删、多入口访问同一份数据 → 用硬链接
跨分区、简化路径、版本切换、快捷方式 → 用软链接（绝大多数场景都用它）