嵌入式C语言文件操作(IO读写）手写面试题及参考答案

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fp;
fp = fopen("example.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
return EXIT_FAILURE;
}
// 可以在这里添加代码来读取文件内容
fclose(fp); // 关闭文件
return EXIT_SUCCESS;
}

尝试以只写模式打开一个不存在的文件，并检查返回的文件指针是否为NULL

当你以只写模式("w"模式)调用fopen时，如果文件不存在，fopen会创建这个文件并返回一个指向它的文件指针。如果由于权限或其他原因无法创建文件，fopen会返回NULL。

下面是一个示例，展示了如何以只写模式打开一个不存在的文件，并检查返回值：

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fp;
fp = fopen("newfile.txt", "w");
if (fp == NULL) {
fprintf(stderr, "Failed to create/open file: %s\n", strerror(errno));
return EXIT_FAILURE;
}
// 在这里可以添加代码来写入文件
fclose(fp);
return EXIT_SUCCESS;
}

使用fclose函数关闭一个已打开的文件，并检查其返回值

fclose函数用于关闭一个已经打开的文件。它返回0表示成功，非零值表示失败。当fclose失败时，errno会被设置，可以通过strerror函数来获取错误描述。

下面是一个示例，展示了如何使用fclose关闭一个文件，并检查其返回值：

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fp;
fp = fopen("example.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
return EXIT_FAILURE;
}
int closeStatus = fclose(fp);
if (closeStatus != 0) {
fprintf(stderr, "Failed to close file: %s\n", strerror(errno));
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}

编写一个程序，打开一个文件并立即尝试关闭它，观察会发生什么

通常情况下，立即关闭一个刚打开的文件不会有任何问题。fclose函数会关闭文件并释放相关资源。以下是一个示例：

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fp;
fp = fopen("example.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
return EXIT_FAILURE;
}
fclose(fp); // 立即关闭文件
return EXIT_SUCCESS;
}

在一个循环中反复打开和关闭同一个文件，直到fopen失败

这通常用于测试文件系统或文件权限限制。每次打开和关闭文件都会消耗系统资源，因此，反复这样做可能会导致资源耗尽，尤其是在短时间内。

下面是一个示例，演示了如何在一个循环中反复打开和关闭同一个文件：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> // 用于sleep函数

int main() {
FILE *fp;
int i;
for (i = 0; i < 100; i++) {
fp = fopen("example.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Failed to open file after %d attempts: %s\n", i, strerror(errno));
break;
}
fclose(fp);
sleep(1); // 休眠一秒，避免过于频繁的操作
}
return EXIT_SUCCESS;
}

用freopen函数重新定向标准输入到一个文件

freopen函数可以重新定向标准输入或输出流到一个新的文件。下面是一个示例，展示了如何使用freopen重新定向标准输入到一个文件：

#include <stdio.h>
#include <stdlib.h>

int main() {
freopen("input.txt", "r", stdin); // 重新定向标准输入
if (stdin == NULL) {
fprintf(stderr, "Failed to redirect stdin: %s\n", strerror(errno));
return EXIT_FAILURE;
}
// 接下来可以读取来自input.txt的内容
return EXIT_SUCCESS;
}

尝试用freopen函数将标准输出重定向到一个新文件

与重新定向标准输入类似，freopen也可以用于标准输出。以下是一个示例，展示了如何使用freopen将标准输出重定向到一个新文件：

#include <stdio.h>
#include <stdlib.h>

int main() {
freopen("output.txt", "w", stdout); // 重新定向标准输出
if (stdout == NULL) {
fprintf(stderr, "Failed to redirect stdout: %s\n", strerror(errno));
return EXIT_FAILURE;
}
printf("Hello, world!\n"); // 输出将会被写入output.txt
return EXIT_SUCCESS;
}

使用setvbuf设置文件流的缓冲类型，并验证其效果

setvbuf函数允许你设置文件流的缓冲行为。例如，你可以设置缓冲为全缓冲(_IOFBF)、行缓冲(_IOLBF)或无缓冲(_IONBF)。下面是一个示例，展示了如何使用setvbuf：

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fp;
fp = fopen("example.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
return EXIT_FAILURE;
}
setvbuf(fp, NULL, _IOFBF, 1024); // 设置全缓冲
// 这里可以读取文件，缓冲区的大小和类型会影响读取效率
fclose(fp);
return EXIT_SUCCESS;
}

使用setbuffer函数自定义文件缓冲区大小

setbuffer函数允许你指定缓冲区的起始地址和大小。下面是一个示例，展示了如何使用setbuffer：

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fp;
char buffer[4096];
fp = fopen("example.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
return EXIT_FAILURE;
}
setbuffer(fp, buffer, 4096); // 设置自定义缓冲区
// 读取文件，使用自定义的缓冲区
fclose(fp);
return EXIT_SUCCESS;
}

编写一个程序，展示如何使用tmpfile创建一个临时文件

tmpfile函数用于创建一个临时文件，并返回指向该文件的文件指针。下面是一个示例，展示了如何使用tmpfile：

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fp;
fp = tmpfile();
if (fp == NULL) {
fprintf(stderr, "Failed to create temporary file: %s\n", strerror(errno));
return EXIT_FAILURE;
}
fprintf(fp, "This is a test message.\n");
rewind(fp); // 移动文件指针到开头
char line[100];
fgets(line, sizeof(line), fp);
printf("Read from temporary file: %s", line);
fclose(fp);
return EXIT_SUCCESS;
}

这些示例程序涵盖了C语言中基本的文件操作，包括打开、关闭、读写、以及一些高级的文件流控制功能。在实际应用中，应该根据具体需求选择合适的函数，并确保正确处理所有可能的错误情况。

从一个文件中读取单个字符，直到遇到文件结束符

在C语言中，使用fgetc函数可以从文件中读取单个字符，直到遇到文件结束符EOF。下面是一个示例程序，展示了如何使用fgetc从文件中读取单个字符：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("input.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Error opening file.");
return 1;
}

int ch;
while ((ch = fgetc(fp)) != EOF) {
// 处理字符
printf("%c", ch);
}

fclose(fp);
return 0;
}

向文件写入一系列字符，并验证结果

为了向文件写入一系列字符，可以使用fputc或fprintf等函数。下面的示例程序使用fputc向文件写入一系列字符，并通过再次读取文件来验证结果：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("output.txt", "w");
if (fp == NULL) {
fprintf(stderr, "Error opening file.");
return 1;
}

const char *text = "Hello, World!";
int i;
for (i = 0; text[i] != '\0'; ++i) {
fputc(text[i], fp);
}

fclose(fp);

// 验证结果
fp = fopen("output.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Error reopening file.");
return 1;
}

char ch;
while ((ch = fgetc(fp)) != EOF) {
printf("%c", ch);
}

fclose(fp);
return 0;
}

使用fgetc和fputc函数进行单字符读写操作

fgetc和fputc分别用于从文件读取和向文件写入单个字符。下面的程序演示了这两个函数的使用：

#include <stdio.h>

int main() {
FILE *fp_in, *fp_out;
fp_in = fopen("source.txt", "r");
fp_out = fopen("destination.txt", "w");

if (fp_in == NULL || fp_out == NULL) {
fprintf(stderr, "Error opening files.");
fclose(fp_in);
fclose(fp_out);
return 1;
}

int ch;
while ((ch = fgetc(fp_in)) != EOF) {
fputc(ch, fp_out);
}

fclose(fp_in);
fclose(fp_out);
return 0;
}

利用getc和putc函数，不指定文件指针，直接读写标准输入/输出

getc和putc函数默认使用stdin和stdout作为文件指针。下面的程序展示了如何使用这两个函数直接从标准输入读取并写入标准输出：

#include <stdio.h>

int main() {
int ch;

while ((ch = getc(stdin)) != EOF) {
putc(ch, stdout);
}

return 0;
}

使用ungetc函数将字符放回输入流

ungetc函数允许你将最近读取的一个字符放回输入流，以便再次读取。下面是一个示例程序：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("input.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Error opening file.");
return 1;
}

int ch;
while ((ch = fgetc(fp)) != EOF) {
if (ch == 'a') {
ungetc(ch, fp);
continue;
}
printf("%c", ch);
}

fclose(fp);
return 0;
}

演示getchar和putchar函数的用法

getchar和putchar函数用于读取和写入单个字符，它们默认使用标准输入和标准输出。下面是一个示例程序：

#include <stdio.h>

int main() {
int ch;

printf("Enter some text: ");
while ((ch = getchar()) != '\n') {
putchar(ch);
}

return 0;
}

编写一个程序，从文件中读取一个字符，然后将其大写后写回到同一文件

这个任务需要在读取和写入之间重新定位文件指针，因为通常不能在同一位置同时读取和写入。下面是一个示例程序，实现了这个功能：

#include <stdio.h>
#include <ctype.h>

int main() {
FILE *fp;
fp = fopen("input.txt", "r+");
if (fp == NULL) {
fprintf(stderr, "Error opening file.");
return 1;
}

int ch;
while ((ch = fgetc(fp)) != EOF) {
ch = toupper(ch);
fseek(fp, -1L, SEEK_CUR);
fputc(ch, fp);
fseek(fp, 1L, SEEK_CUR);
}

fclose(fp);
return 0;
}

创建一个程序，将一个文件的内容反转并写入另一个文件

要实现文件内容的反转，可以先将文件内容读入内存，再从后向前写入另一个文件。下面是一个示例程序：

#include <stdio.h>
#include <string.h>

int main() {
FILE *fp_in, *fp_out;
fp_in = fopen("source.txt", "r");
fp_out = fopen("reversed.txt", "w");

if (fp_in == NULL || fp_out == NULL) {
fprintf(stderr, "Error opening files.");
fclose(fp_in);
fclose(fp_out);
return 1;
}

char buffer[1024];
size_t len;
while ((len = fread(buffer, 1, sizeof(buffer), fp_in)) > 0) {
for (size_t i = len - 1; i != (size_t)-1; --i) {
fputc(buffer[i], fp_out);
}
}

fclose(fp_in);
fclose(fp_out);
return 0;
}

实现一个函数，读取文件中的所有字符，统计并打印每个字符出现的次数

这个任务可以通过读取文件中的每个字符并使用一个数组来跟踪每个字符的出现次数来完成。下面是一个示例程序：

#include <stdio.h>

void count_characters(const char *filename) {
FILE *fp = fopen(filename, "r");
if (fp == NULL) {
fprintf(stderr, "Error opening file.");
return;
}

unsigned int counts[256] = {0};
int ch;
while ((ch = fgetc(fp)) != EOF) {
counts[ch]++;
}

for (int i = 0; i < 256; i++) {
if (counts[i]) {
printf("Character '%c': %u times\n", i, counts[i]);
}
}

fclose(fp);
}

int main() {
count_characters("input.txt");
return 0;
}

编写一个程序，从一个文件读取字符，直到遇到特定的终止字符

这个任务可以通过在读取字符的同时检查字符是否等于终止字符来实现。下面是一个示例程序：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("input.txt", "r");
if (fp == NULL) {
fprintf(stderr, "Error opening file.");
return 1;
}

int ch;
char terminator = ';'; // 终止字符
while ((ch = fgetc(fp)) != EOF && ch != terminator) {
// 处理字符
printf("%c", ch);
}

fclose(fp);
return 0;
}

这些示例程序覆盖了C语言中与文件读写相关的常见操作，包括单字符读写、标准输入输出、字符转换、文件内容处理和统计分析。在实际开发中，确保正确处理文件打开失败和其他潜在错误非常重要。

使用fgets和puts函数读写一行文本

fgets函数用于从文件中读取一行文本，而puts函数用于向标准输出写入一个字符串。下面的示例程序展示了如何使用这两个函数读取和显示文件中的一行文本：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("input.txt", "r");
if (fp == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

char line[100]; // 假设每行不超过99个字符加上结束符
fgets(line, sizeof(line), fp);
puts(line);

fclose(fp);
return 0;
}

使用fputs函数向文件写入一个字符串

fputs函数用于向文件写入一个字符串。下面的示例程序展示了如何使用fputs将一个字符串写入文件：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("output.txt", "w");
if (fp == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

const char *text = "Hello, World!";
fputs(text, fp);

fclose(fp);
return 0;
}

从文件中读取多行文本，并存储在一个数组中

为了读取文件中的多行文本并存储在一个数组中，可以使用fgets函数多次读取，每次读取一行。下面是一个示例程序：

#include <stdio.h>
#include <string.h>

int main() {
FILE *fp;
fp = fopen("input.txt", "r");
if (fp == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

const int max_lines = 10;
const int line_len = 100;
char lines[max_lines][line_len];

int num_lines = 0;
char line[line_len];
while (fgets(line, line_len, fp) != NULL && num_lines < max_lines) {
strcpy(lines[num_lines++], line);
}

fclose(fp);
return 0;
}

将数组中的文本逐行写入文件

有了上面读取多行文本的数组，可以使用fputs或fprintf将数组中的文本逐行写入文件。下面是一个示例程序：

#include <stdio.h>
#include <string.h>

int main() {
FILE *fp;
fp = fopen("output.txt", "w");
if (fp == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

const int max_lines = 10;
const int line_len = 100;
char lines[max_lines][line_len];

// 假设lines已经被填充

for (int i = 0; i < max_lines; ++i) {
fputs(lines[i], fp);
}

fclose(fp);
return 0;
}

使用getline函数读取一行输入，注意它的返回值

getline函数用于读取一行文本，包括换行符。返回值是读取的字符数，包括终止的换行符和空字符。下面是一个示例程序：

#include <stdio.h>
#include <stdlib.h>

int main() {
char *line = NULL;
size_t len = 0;
ssize_t read;

read = getline(&line, &len, stdin);
if (read == -1) {
fprintf(stderr, "Error reading input.");
return 1;
}

printf("You entered: %s", line);
free(line); // 不要忘记释放分配的内存
return 0;
}

编写一个程序，将一个文件的每一行逆序后写入另一个文件

这个任务可以通过读取源文件的一行，逆序字符串，然后写入目标文件来完成。下面是一个示例程序：

#include <stdio.h>
#include <string.h>

void reverse_string(char *str) {
int len = strlen(str);
for (int i = 0, j = len - 1; i < j; ++i, --j) {
char temp = str[i];
str[i] = str[j];
str[j] = temp;
}
}

int main() {
FILE *in_file = fopen("input.txt", "r");
FILE *out_file = fopen("output.txt", "w");

if (in_file == NULL || out_file == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

char line[100];
while (fgets(line, sizeof(line), in_file) != NULL) {
reverse_string(line);
fputs(line, out_file);
}

fclose(in_file);
fclose(out_file);
return 0;
}

实现一个函数，读取文件中的所有行，统计并打印每一行的长度

下面是一个示例程序，它读取文件中的每一行并打印行的长度：

#include <stdio.h>
#include <string.h>

int main() {
FILE *fp;
fp = fopen("input.txt", "r");
if (fp == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

char line[100];
while (fgets(line, sizeof(line), fp) != NULL) {
int len = strlen(line);
printf("Line length: %d\n", len - 1); // 不包括换行符
}

fclose(fp);
return 0;
}

创建一个程序，比较两个文件的内容是否完全相同

比较两个文件的内容可以通过逐行读取并比较来实现。下面是一个示例程序：

#include <stdio.h>
#include <string.h>

int main() {
FILE *file1 = fopen("file1.txt", "r");
FILE *file2 = fopen("file2.txt", "r");

if (file1 == NULL || file2 == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

char line1[100];
char line2[100];
int result = 1;

while (fgets(line1, sizeof(line1), file1) != NULL) {
if (fgets(line2, sizeof(line2), file2) == NULL) {
result = 0;
break;
}
if (strcmp(line1, line2) != 0) {
result = 0;
break;
}
}

if (fgets(line2, sizeof(line2), file2) != NULL) {
result = 0;
}

fclose(file1);
fclose(file2);

if (result) {
printf("Files are identical.\n");
} else {
printf("Files are different.\n");
}

return 0;
}

编写一个程序，将一个文件的内容追加到另一个文件的末尾

将一个文件的内容追加到另一个文件的末尾可以使用fopen的"a"模式和fputs或fwrite函数来实现。下面是一个示例程序：

#include <stdio.h>

int main() {
FILE *src_file = fopen("source.txt", "r");
FILE *dest_file = fopen("destination.txt", "a");

if (src_file == NULL || dest_file == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

char line[100];
while (fgets(line, sizeof(line), src_file) != NULL) {
fputs(line, dest_file);
}

fclose(src_file);
fclose(dest_file);
return 0;
}

使用fscanf和fprintf函数读写格式化的字符串

fscanf和fprintf函数用于读写格式化的字符串，类似于scanf和printf。下面是一个示例程序：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("data.txt", "w");
if (fp == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

int number = 123;
double value = 3.14;
fprintf(fp, "%d %f", number, value);

fclose(fp);

fp = fopen("data.txt", "r");
if (fp == NULL) {
fprintf(stderr, "File opening error.");
return 1;
}

int read_number;
double read_value;
fscanf(fp, "%d %lf", &read_number, &read_value);

printf("Read values: %d, %f\n", read_number, read_value);

fclose(fp);
return 0;
}

这些示例程序展示了C语言中与文件读写相关的多种常见操作，包括读写字符串、处理多行文本、字符串逆序、文件内容比较和格式化读写。在实际应用中，确保正确处理文件打开失败和其他潜在错误是非常重要的。

使用ferror和clearerr函数处理文件错误

在C语言中，ferror函数用于检测上一次对流的操作是否失败，而clearerr函数则用于清除流上的任何错误标志和EOF标志。下面是一个示例，展示了如何使用这两个函数来处理文件错误：

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fp;
fp = fopen("test.txt", "r");
if (fp == NULL) {
perror("fopen failed");
exit(EXIT_FAILURE);
}

// 尝试读取文件
int ch;
while ((ch = fgetc(fp)) != EOF) {
// 正常处理字符...
}

// 检查是否有错误发生
if (ferror(fp)) {
fprintf(stderr, "An error occurred while reading the file.\n");
clearerr(fp); // 清除错误标志
}

fclose(fp);
return 0;
}

编写一个程序，演示feof函数的用法

feof函数用于检查文件是否到达了文件结束（EOF）。下面是一个简单的程序，展示了如何使用feof：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("test.txt", "r");
if (fp == NULL) {
perror("fopen failed");
exit(EXIT_FAILURE);
}

int ch;
while ((ch = fgetc(fp)) != EOF) {
// 处理字符...
if (feof(fp)) {
printf("End of file reached.\n");
break;
}
}

fclose(fp);
return 0;
}

使用fflush函数刷新文件缓冲区

fflush函数用于强制将缓冲区中的数据写入文件。下面是一个示例，展示了如何使用fflush来刷新缓冲区：

#include <stdio.h>

int main() {
FILE *fp;
fp = fopen("test.txt", "w");
if (fp == NULL) {
perror("fopen failed");
exit(EXIT_FAILURE);
}

fprintf(fp, "Hello, World!");

// 强制将缓冲区中的数据写入文件
fflush(fp);

fclose(fp);
return 0;
}

创建一个程序，使用flockfile和funlockfile实现文件的线程安全访问

在多线程环境中，flockfile和funlockfile函数用于确保对文件流的互斥访问。下面是一个示例，展示了如何使用这两个函数：

#include <stdio.h>
#include <pthread.h>

void *thread_function(void *arg) {
FILE *fp = (FILE *)arg;

// 锁定文件流
flockfile(fp);
fprintf(fp, "Thread writing...\n");
fflush(fp);
funlockfile(fp);

pthread_exit(NULL);
}

int main() {
FILE *fp;
fp = fopen("test.txt", "w");
if (fp == NULL) {
perror("fopen failed");
exit(EXIT_FAILURE);
}

pthread_t thread_id;
pthread_create(&thread_id, NULL, thread_function, fp);

// 主线程也写入数据
flockfile(fp);
fprintf(fp, "Main thread writing...\n");
fflush(fp);
funlockfile(fp);

pthread_join(thread_id, NULL);

fclose(fp);
return 0;
}

使用ftrylockfile尝试锁定文件而不阻塞

ftrylockfile函数试图锁定文件流，如果文件流已经被锁定，则立即返回。下面是一个示例，展示了如何使用ftrylockfile：

#include <stdio.h>
#include <pthread.h>

void *thread_function(void *arg) {
FILE *fp = (FILE *)arg;

if (!ftrylockfile(fp)) {
// 如果不能立即获得锁，则不写入数据
return NULL;
}

fprintf(fp, "Thread writing...\n");
fflush(fp);
funlockfile(fp);

pthread_exit(NULL);
}

int main() {
FILE *fp;
fp = fopen("test.txt", "w");
if (fp == NULL) {
perror("fopen failed");
exit(EXIT_FAILURE);
}

pthread_t thread_id;
pthread_create(&thread_id, NULL, thread_function, fp);

// 主线程也写入数据
if (!ftrylockfile(fp)) {
return 0;
}

fprintf(fp, "Main thread writing...\n");
fflush(fp);
funlockfile(fp);

pthread_join(thread_id, NULL);

fclose(fp);
return 0;
}

编写一个程序，演示如何使用fdatasync同步文件数据到磁盘

fdatasync函数用于同步文件数据到磁盘，但不包括元数据（如文件大小、权限等）。下面是一个示例，展示了如何使用fdatasync：

#include <stdio.h>
#include <unistd.h> // for fdatasync

int main() {
FILE *fp;
fp = fopen("test.txt", "w");
if (fp == NULL) {
perror("fopen failed");
exit(EXIT_FAILURE);
}

fprintf(fp, "Hello, World!");
fflush(fp);

// 同步文件数据到磁盘
if (fdatasync(fileno(fp)) == -1) {
perror("fdatasync failed");
exit(EXIT_FAILURE);
}

fclose(fp);
return 0;
}

使用fseeko和ftello函数，处理大文件（大于2GB）

fseeko和ftello函数允许你在大文件中进行定位和获取文件指针位置，它们使用off_t类型，适用于处理大于2GB的文件。下面是一个示例，展示了如何使用这两个函数：

#include <stdio.h>
#include <sys/types.h>

int main() {
FILE *fp;
fp = fopen("largefile.bin", "r+");
if (fp == NULL) {
perror("fopen failed");
exit(EXIT_FAILURE);
}

off_t pos = 1024 * 1024 * 1024; // 定位到1GB处
if (fseeko(fp, pos, SEEK_SET) == -1) {
perror("fseeko failed");
fclose(fp);
exit(EXIT_FAILURE);
}

// 写入数据
fprintf(fp, "Data at 1GB offset.");

// 获取当前位置
off_t current_pos = ftello(fp);
if (current_pos == (off_t)-1) {
perror("ftello failed");
fclose(fp);
exit(EXIT_FAILURE);
}

printf("Current position: %ld\n", current_pos);

fclose(fp);
return 0;
}

创建一个程序，使用pwrite和pread函数进行随机文件访问

pwrite和pread函数允许你对文件进行随机写入和读取操作，即使在没有文件缓存的情况下也能工作。下面是一个示例，展示了如何使用这两个函数：

#include <stdio.h>
#include <unistd.h> // for pwrite and pread

int main() {
int fd;
fd = open("random_access_file.bin", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
if (fd == -1) {
perror("open failed");
exit(EXIT_FAILURE);
}

const char *data = "Random data.";
off_t offset = 1024 * 1024; // 1MB处

// 写入数据
ssize_t bytes_written = pwrite(fd, data, strlen(data), offset);
if (bytes_written == -1) {
perror("pwrite failed");
close(fd);
exit(EXIT_FAILURE);
}

char buffer[100];
// 读取数据
ssize_t bytes_read = pread(fd, buffer, sizeof(buffer), offset);
if (bytes_read == -1) {
perror("pread failed");
close(fd);
exit(EXIT_FAILURE);
}

printf("Read data: %.*s\n", (int)bytes_read, buffer);

close(fd);
return 0;
}

使用fmemopen函数在内存中创建一个文件流

fmemopen函数用于在内存中创建一个文件流，下面是一个示例，展示了如何使用fmemopen：

#include <stdio.h>
#include <stdlib.h>

int main() {
char *buffer = malloc(100);
memset(buffer, 0, 100);

FILE *fp;
fp = fmemopen(buffer, 100, "w+");
if (fp == NULL) {
perror("fmemopen failed");
free(buffer);
exit(EXIT_FAILURE);
}

fprintf(fp, "Memory data.");
rewind(fp); // 重置文件指针到开始

char read_buffer[100];
fread(read_buffer, 1, 100, fp);
printf("Read data: %s\n", read_buffer);

fclose(fp);
free(buffer);
return 0;
}

实现一个函数，使用fopencookie和fclose来访问一个自定义的文件系统

fopencookie函数允许你创建一个自定义的文件流，下面是一个示例，展示了如何使用fopencookie来访问自定义文件系统：

#include <stdio.h>
#include <stdlib.h>

struct my_cookie {
void *data;
};

static int my_read(void *cookie, char *buf, int len) {
struct my_cookie *myc = (struct my_cookie *)cookie;
// 实现读取操作...
return len; // 返回读取的字节数
}

static int my_write(void *cookie, const char *buf, int len) {
struct my_cookie *myc = (struct my_cookie *)cookie;
// 实现写入操作...
return len; // 返回写入的字节数
}

static int my_seek(void *cookie, int pos, int whence) {
struct my_cookie *myc = (struct my_cookie *)cookie;
// 实现定位操作...
return pos; // 返回新的位置
}

static int my_close(void *cookie) {
struct my_cookie *myc = (struct my_cookie *)cookie;
// 实现关闭操作...
free(myc->data);
free(myc);
return 0;
}

FILE *my_fopen(const char *path, const char *mode) {
struct my_cookie *myc = malloc(sizeof(struct my_cookie));
myc->data = malloc(100); // 分配数据空间

FILE *fp = fopencookie(myc, mode, my_read, my_write, my_seek, my_close);
if (fp == NULL) {
free(myc->data);
free(myc);
}
return fp;
}

int main() {
FILE *fp;
fp = my_fopen("custom_file", "w+");
if (fp == NULL) {
perror("my_fopen failed");
exit(EXIT_FAILURE);
}

fprintf(fp, "Custom file data.");
rewind(fp); // 重置文件指针到开始

char read_buffer[100];
fread(read_buffer, 1, 100, fp);
printf("Read data: %s\n", read_buffer);

fclose(fp);
return 0;
}

这些示例程序覆盖了C语言中文件操作的高级功能，包括错误处理、线程安全、数据同步、大文件支持、随机文件访问以及自定义文件系统接口。在实际开发中，确保正确处理各种异常情况和错误是至关重要的。

使用stat函数获取文件的状态信息

stat函数用于获取指定文件的状态信息，这包括文件的大小、权限、所有者、组、最后修改时间等。下面是一个示例程序，展示了如何使用stat：

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>

int main() {
struct stat file_info;
const char *filename = "example.txt";

if (stat(filename, &file_info) == -1) {
perror("Failed to get file information");
return 1;
}

printf("File size: %lld bytes\n", (long long)file_info.st_size);
printf("File permissions: %o\n", file_info.st_mode & 0777);
printf("Last modified: %s", ctime(&file_info.st_mtime));

return 0;
}

编写一个程序，使用fstat函数获取文件描述符的文件状态

fstat函数类似于stat，但它通过文件描述符而不是文件名来获取文件状态信息。下面是一个示例：

#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>

int main() {
struct stat file_info;
int fd = open("example.txt", O_RDONLY);

if (fd == -1) {
perror("Failed to open file");
return 1;
}

if (fstat(fd, &file_info) == -1) {
perror("Failed to get file information");
close(fd);
return 1;
}

printf("File size: %lld bytes\n", (long long)file_info.st_size);
printf("File permissions: %o\n", file_info.st_mode & 0777);
printf("Last modified: %s", ctime(&file_info.st_mtime));

close(fd);
return 0;
}

使用lstat函数获取符号链接的目标文件状态

lstat函数用于获取符号链接本身的状态信息，而不是它指向的目标文件的信息。下面是一个示例程序：

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>

int main() {
struct stat link_info;
const char *linkname = "example_link";

if (lstat(linkname, &link_info) == -1) {
perror("Failed to get symbolic link information");
return 1;
}

printf("Link target inode: %lld\n", (long long)link_info.st_ino);
printf("Link permissions: %o\n", link_info.st_mode & 0777);

return 0;
}

创建一个程序，显示文件的最后修改时间

你可以使用stat函数结合ctime函数来显示文件的最后修改时间。以下是一个示例：

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>

int main() {
struct stat file_info;
const char *filename = "example.txt";

if (stat(filename, &file_info) == -1) {
perror("Failed to get file information");
return 1;
}

printf("Last modified: %s", ctime(&file_info.st_mtime));

return 0;
}

使用chmod函数改变文件权限

chmod函数用于改变文件的权限。下面是一个示例程序，展示如何使用chmod：

#include <stdio.h>
#include <sys/stat.h>

int main() {
const char *filename = "example.txt";
mode_t mode = 0644; // 设置为rw-r--r--

if (chmod(filename, mode) == -1) {
perror("Failed to change file permissions");
return 1;
}

printf("Permissions changed successfully.\n");

return 0;
}

编写一个程序，使用chown函数更改文件的所有者

chown函数用于更改文件的所有者和组。以下是一个示例程序：

#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

int main() {
const char *filename = "example.txt";
uid_t owner = 1000; // UID of the new owner
gid_t group = 1000; // GID of the new group

if (chown(filename, owner, group) == -1) {
perror("Failed to change file ownership");
return 1;
}

printf("Ownership changed successfully.\n");

return 0;
}

使用truncate函数截断文件

truncate函数用于截断文件到指定的长度。以下是一个示例程序：

#include <stdio.h>
#include <unistd.h>

int main() {
const char *filename = "example.txt";
off_t size = 100; // 截断至100字节

if (truncate(filename, size) == -1) {
perror("Failed to truncate file");
return 1;
}

printf("File truncated successfully.\n");

return 0;
}

创建一个程序，使用link函数创建硬链接

link函数用于创建硬链接。以下是一个示例程序：

#include <stdio.h>
#include <unistd.h>

int main() {
const char *oldname = "example.txt";
const char *newname = "example_link.txt";

if (link(oldname, newname) == -1) {
perror("Failed to create hard link");
return 1;
}

printf("Hard link created successfully.\n");

return 0;
}

使用symlink函数创建符号链接

symlink函数用于创建符号链接。以下是一个示例程序：

#include <stdio.h>
#include <unistd.h>

int main() {
const char *target = "example.txt";
const char *linkname = "example_link";

if (symlink(target, linkname) == -1) {
perror("Failed to create symbolic link");
return 1;
}

printf("Symbolic link created successfully.\n");

return 0;
}

编写一个程序，使用readlink函数读取符号链接的目标路径

readlink函数用于读取符号链接指向的目标路径。以下是一个示例程序：

#include <stdio.h>
#include <unistd.h>

int main() {
const char *linkname = "example_link";
char buf[100]; // 足够大的缓冲区以保存目标路径

if (readlink(linkname, buf, sizeof(buf) - 1) == -1) {
perror("Failed to read symbolic link");
return 1;
}

buf[sizeof(buf) - 1] = '\0'; // 确保字符串以null结尾
printf("Target path: %s\n", buf);

return 0;
}

这些示例程序涵盖了C语言中与文件状态、权限、所有者、链接操作相关的基本函数的使用。在实际编程中，确保正确处理错误和边缘情况是非常重要的，例如检查函数调用的返回值，确保文件和链接的存在性，以及处理可能的权限问题。

创建一个程序，过滤出目录下所有.txt文件

要过滤出目录下的所有.txt文件，你可以使用dirent.h库中的opendir，readdir和closedir函数。下面是一个示例程序，展示了如何列出当前目录下所有的.txt文件：

#include <stdio.h>
#include <dirent.h>

int main() {
DIR *dir;
struct dirent *ent;
if ((dir = opendir(".")) != NULL) {
while ((ent = readdir(dir)) != NULL) {
if (strstr(ent->d_name, ".txt") != NULL) {
printf("%s\n", ent->d_name);
}
}
closedir(dir);
} else {
perror("Could not open directory");
return EXIT_FAILURE;
}
return 0;
}

编写一个程序，将目录下的文件按大小排序

要按文件大小排序，你需要先收集所有文件的大小，然后对这些大小进行排序，同时保持文件名和大小之间的关联。下面是一个示例程序，展示了如何按大小排序目录下的文件：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <stdlib.h>

#define MAX_FILES 100

struct FileInfo {
char filename[256];
off_t size;
};

int compare(const void *a, const void *b) {
struct FileInfo *fileA = (struct FileInfo *)a;
struct FileInfo *fileB = (struct FileInfo *)b;
return (fileA->size > fileB->size) - (fileA->size < fileB->size);
}

int main() {
DIR *dir;
struct dirent *ent;
struct FileInfo files[MAX_FILES];
int count = 0;
if ((dir = opendir(".")) != NULL) {
while ((ent = readdir(dir)) != NULL) {
if (ent->d_type == DT_REG) {
struct stat st;
if (stat(ent->d_name, &st) == 0) {
if (count < MAX_FILES) {
files[count].size = st.st_size;
strncpy(files[count].filename, ent->d_name, sizeof(files[count].filename) - 1);
files[count].filename[sizeof(files[count].filename) - 1] = '\0';
count++;
}
}
}
}
closedir(dir);
qsort(files, count, sizeof(struct FileInfo), compare);
for (int i = 0; i < count; i++) {
printf("%s (%llu bytes)\n", files[i].filename, (unsigned long long)files[i].size);
}
} else {
perror("Could not open directory");
return EXIT_FAILURE;
}
return 0;
}

实现一个函数，将目录下的文件按修改时间排序

类似地，你可以使用stat函数获取每个文件的修改时间，然后按修改时间排序。以下是一个示例程序，展示了如何按修改时间排序目录下的文件：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <stdlib.h>
#include <time.h>

#define MAX_FILES 100

struct FileInfo {
char filename[256];
time_t mtime;
};

int compare_time(const void *a, const void *b) {
struct FileInfo *fileA = (struct FileInfo *)a;
struct FileInfo *fileB = (struct FileInfo *)b;
return (fileA->mtime > fileB->mtime) - (fileA->mtime < fileB->mtime);
}

int main() {
DIR *dir;
struct dirent *ent;
struct FileInfo files[MAX_FILES];
int count = 0;
if ((dir = opendir(".")) != NULL) {
while ((ent = readdir(dir)) != NULL) {
if (ent->d_type == DT_REG) {
struct stat st;
if (stat(ent->d_name, &st) == 0) {
if (count < MAX_FILES) {
files[count].mtime = st.st_mtim.tv_sec;
strncpy(files[count].filename, ent->d_name, sizeof(files[count].filename) - 1);
files[count].filename[sizeof(files[count].filename) - 1] = '\0';
count++;
}
}
}
}
closedir(dir);
qsort(files, count, sizeof(struct FileInfo), compare_time);
for (int i = 0; i < count; i++) {
printf("%s (last modified: %s)", files[i].filename, ctime(&files[i].mtime));
}
} else {
perror("Could not open directory");
return EXIT_FAILURE;
}
return 0;
}

创建一个程序，过滤并显示目录下所有大于1MB的文件

为了过滤并显示大于1MB的文件，你可以再次使用stat函数来获取文件大小，然后检查文件大小是否超过1MB。以下是一个示例程序：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>

int main() {
DIR *dir;
struct dirent *ent;
if ((dir = opendir(".")) != NULL) {
while ((ent = readdir(dir)) != NULL) {
if (ent->d_type == DT_REG) {
struct stat st;
if (stat(ent->d_name, &st) == 0) {
if (st.st_size > 1024 * 1024) {
printf("%s (%llu bytes)\n", ent->d_name, (unsigned long long)st.st_size);
}
}
}
}
closedir(dir);
} else {
perror("Could not open directory");
return EXIT_FAILURE;
}
return 0;
}

编写一个程序，将目录下的文件按扩展名分组

要将文件按扩展名分组，你可以遍历目录并使用字符串操作来提取文件扩展名，然后根据扩展名对文件进行分组。下面是一个示例程序：

#include <stdio.h>
#include <dirent.h>
#include <string.h>

int main() {
DIR *dir;
struct dirent *ent;
if ((dir = opendir(".")) != NULL) {
while ((ent = readdir(dir)) != NULL) {
char *dot = strrchr(ent->d_name, '.');
if (dot != NULL) {
char ext[256];
strncpy(ext, dot + 1, sizeof(ext) - 1);
ext[sizeof(ext) - 1] = '\0';
printf("File: %s, Extension: %s\n", ent->d_name, ext);
}
}
closedir(dir);
} else {
perror("Could not open directory");
return EXIT_FAILURE;
}
return 0;
}

使用rename函数重命名文件

rename函数用于重命名或移动文件。以下是一个简单的示例程序：

#include <stdio.h>
#include <unistd.h>

int main() {
const char *oldname = "oldfile.txt";
const char *newname = "newfile.txt";

if (rename(oldname, newname) != 0) {
perror("Failed to rename file");
return EXIT_FAILURE;
}
printf("File renamed successfully.\n");
return 0;
}

使用remove函数删除文件

remove函数用于删除文件。以下是一个简单的示例程序：

#include <stdio.h>
#include <unistd.h>

int main() {
const char *filename = "filetodelete.txt";

if (remove(filename) != 0) {
perror("Failed to delete file");
return EXIT_FAILURE;
}
printf("File deleted successfully.\n");
return 0;
}

创建一个程序，使用mkfifo函数创建FIFO特殊文件

mkfifo函数用于创建FIFO（先进先出）特殊文件。以下是一个示例程序：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>

int main() {
const char *fifo_name = "myfifo";
mode_t mode = 0666; // 设置文件权限

if (mkfifo(fifo_name, mode) == -1) {
perror("Failed to create FIFO");
return EXIT_FAILURE;
}
printf("FIFO created successfully.\n");
return 0;
}

这些示例程序展示了C语言中与文件和目录操作相关的多种技术，包括文件过滤、排序、重命名、删除以及创建FIFO文件。在实际编程中，确保正确处理错误和边缘情况是非常重要的，例如检查函数调用的返回值，确保文件和目录的存在性，以及处理可能的权限问题。