C语言获取文件的行数据的核心方法是：使用文件I/O函数、逐行读取、处理和存储数据。 其中，使用fgets()函数来逐行读取文件内容是最常见和有效的方法之一。接下来我们将详细介绍如何在C语言中实现这一过程，并提供一些实用的代码示例和注意事项。
一、文件I/O基础
1、打开文件
在C语言中，打开文件的函数是fopen(), 它的语法格式如下：
FILE *fopen(const char *filename, const char *mode);
filename是要打开的文件的名称。mode是文件的打开模式，比如r（读）、w（写）、a（追加）等。
示例代码：
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
2、逐行读取文件内容
使用fgets()函数可以从文件中逐行读取内容。它的语法格式如下：
char *fgets(char *str, int n, FILE *stream);
str是用来存储读取内容的字符数组。n是要读取的最大字符数（包含终止符）。stream是文件流。
示例代码：
char buffer[256];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
printf("%s", buffer);
}
3、关闭文件
使用fclose()函数关闭文件，以释放资源：
fclose(file);
二、错误处理
在处理文件I/O时，必须考虑可能出现的错误情况，比如文件无法打开、读取失败等。应使用perror()或fprintf(stderr, ...)等方法输出错误信息。
示例代码：
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
// 逐行读取和处理文件内容
char buffer[256];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
printf("%s", buffer);
}
if (ferror(file)) {
perror("Error reading file");
}
fclose(file);
三、逐行读取并处理数据
1、存储每行数据
在实际应用中，通常需要将每行数据存储在一个数据结构中，比如数组或链表，以便后续处理。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINES 1000
#define MAX_LINE_LENGTH 256
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
char lines = malloc(MAX_LINES * sizeof(char *));
if (lines == NULL) {
perror("Failed to allocate memory");
fclose(file);
return 1;
}
char buffer[MAX_LINE_LENGTH];
int line_count = 0;
while (fgets(buffer, sizeof(buffer), file) != NULL && line_count < MAX_LINES) {
lines[line_count] = strdup(buffer);
if (lines[line_count] == NULL) {
perror("Failed to duplicate string");
break;
}
line_count++;
}
fclose(file);
// 处理读取的每行数据
for (int i = 0; i < line_count; i++) {
printf("%s", lines[i]);
free(lines[i]);
}
free(lines);
return 0;
}
2、处理数据
在实际应用中，读取文件内容后，通常需要对数据进行处理，比如数据解析、过滤、统计等。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINES 1000
#define MAX_LINE_LENGTH 256
void process_line(const char *line) {
// 这里添加处理逻辑，比如解析、过滤、统计等
printf("Processing line: %s", line);
}
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
char buffer[MAX_LINE_LENGTH];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
process_line(buffer);
}
fclose(file);
return 0;
}
四、使用高级数据结构
1、使用链表存储数据
链表是一种常见的数据结构，可以动态地分配和释放存储空间。使用链表存储文件的每行数据，可以有效地处理不确定行数的文件。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINE_LENGTH 256
typedef struct LineNode {
char *line;
struct LineNode *next;
} LineNode;
LineNode* create_node(const char *line) {
LineNode *node = malloc(sizeof(LineNode));
if (node == NULL) {
perror("Failed to allocate memory");
return NULL;
}
node->line = strdup(line);
if (node->line == NULL) {
perror("Failed to duplicate string");
free(node);
return NULL;
}
node->next = NULL;
return node;
}
void free_list(LineNode *head) {
LineNode *current = head;
while (current != NULL) {
LineNode *next = current->next;
free(current->line);
free(current);
current = next;
}
}
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
LineNode *head = NULL;
LineNode *tail = NULL;
char buffer[MAX_LINE_LENGTH];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
LineNode *node = create_node(buffer);
if (node == NULL) {
free_list(head);
fclose(file);
return 1;
}
if (tail == NULL) {
head = tail = node;
} else {
tail->next = node;
tail = node;
}
}
fclose(file);
// 处理链表中的每行数据
LineNode *current = head;
while (current != NULL) {
printf("%s", current->line);
current = current->next;
}
free_list(head);
return 0;
}
2、使用动态数组存储数据
动态数组也是一种有效的数据结构，可以根据需要动态调整大小。使用动态数组存储文件的每行数据，可以处理不确定行数的文件。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define INITIAL_CAPACITY 10
#define MAX_LINE_LENGTH 256
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
char lines = malloc(INITIAL_CAPACITY * sizeof(char *));
if (lines == NULL) {
perror("Failed to allocate memory");
fclose(file);
return 1;
}
int capacity = INITIAL_CAPACITY;
int line_count = 0;
char buffer[MAX_LINE_LENGTH];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
if (line_count >= capacity) {
capacity *= 2;
char new_lines = realloc(lines, capacity * sizeof(char *));
if (new_lines == NULL) {
perror("Failed to reallocate memory");
break;
}
lines = new_lines;
}
lines[line_count] = strdup(buffer);
if (lines[line_count] == NULL) {
perror("Failed to duplicate string");
break;
}
line_count++;
}
fclose(file);
// 处理读取的每行数据
for (int i = 0; i < line_count; i++) {
printf("%s", lines[i]);
free(lines[i]);
}
free(lines);
return 0;
}
五、使用多线程处理文件
在处理大文件时，可以使用多线程来提高效率。多线程允许同时读取和处理多个行，从而减少总的处理时间。
1、创建线程
在C语言中，可以使用pthread库创建和管理线程。pthread_create()函数用于创建新线程。
示例代码：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINE_LENGTH 256
void *process_line(void *arg) {
char *line = (char *)arg;
// 这里添加处理逻辑，比如解析、过滤、统计等
printf("Processing line: %s", line);
free(line);
return NULL;
}
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
char buffer[MAX_LINE_LENGTH];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
char *line = strdup(buffer);
if (line == NULL) {
perror("Failed to duplicate string");
break;
}
pthread_t thread;
if (pthread_create(&thread, NULL, process_line, line) != 0) {
perror("Failed to create thread");
free(line);
break;
}
pthread_detach(thread);
}
fclose(file);
return 0;
}
2、同步和互斥
在多线程环境中，必须考虑线程同步和互斥问题，以避免数据竞争和不一致性。使用pthread_mutex_t和pthread_cond_t等同步机制可以有效解决这些问题。
示例代码：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINE_LENGTH 256
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *process_line(void *arg) {
char *line = (char *)arg;
pthread_mutex_lock(&mutex);
// 这里添加处理逻辑，比如解析、过滤、统计等
printf("Processing line: %s", line);
pthread_mutex_unlock(&mutex);
free(line);
return NULL;
}
int main() {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
char buffer[MAX_LINE_LENGTH];
while (fgets(buffer, sizeof(buffer), file) != NULL) {
char *line = strdup(buffer);
if (line == NULL) {
perror("Failed to duplicate string");
break;
}
pthread_t thread;
if (pthread_create(&thread, NULL, process_line, line) != 0) {
perror("Failed to create thread");
free(line);
break;
}
pthread_detach(thread);
}
fclose(file);
return 0;
}
六、性能优化
1、使用内存映射文件
内存映射文件是一种高级技术，它允许将文件内容映射到进程的地址空间，从而提高文件读取和写入的效率。在Unix-like系统中，可以使用mmap()函数实现内存映射文件。
示例代码：
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
int main() {
int fd = open("example.txt", O_RDONLY);
if (fd == -1) {
perror("Failed to open file");
return 1;
}
struct stat sb;
if (fstat(fd, &sb) == -1) {
perror("Failed to get file status");
close(fd);
return 1;
}
char *file_content = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (file_content == MAP_FAILED) {
perror("Failed to map file");
close(fd);
return 1;
}
close(fd);
// 处理文件内容
for (off_t i = 0; i < sb.st_size; i++) {
putchar(file_content[i]);
}
if (munmap(file_content, sb.st_size) == -1) {
perror("Failed to unmap file");
}
return 0;
}
2、使用多重缓冲
多重缓冲是一种常用的优化技术，通过使用多个缓冲区，可以提高数据读取和处理的效率。多重缓冲可以减少I/O等待时间，提高CPU利用率。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#define BUFFER_SIZE 256
#define NUM_BUFFERS 4
typedef struct {
char data[BUFFER_SIZE];
int ready;
pthread_mutex_t mutex;
pthread_cond_t cond;
} Buffer;
Buffer buffers[NUM_BUFFERS];
int current_buffer = 0;
void *producer(void *arg) {
FILE *file = fopen("example.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return NULL;
}
while (1) {
pthread_mutex_lock(&buffers[current_buffer].mutex);
while (buffers[current_buffer].ready) {
pthread_cond_wait(&buffers[current_buffer].cond, &buffers[current_buffer].mutex);
}
if (fgets(buffers[current_buffer].data, BUFFER_SIZE, file) == NULL) {
buffers[current_buffer].ready = -1;
pthread_cond_signal(&buffers[current_buffer].cond);
pthread_mutex_unlock(&buffers[current_buffer].mutex);
break;
}
buffers[current_buffer].ready = 1;
pthread_cond_signal(&buffers[current_buffer].cond);
pthread_mutex_unlock(&buffers[current_buffer].mutex);
current_buffer = (current_buffer + 1) % NUM_BUFFERS;
}
fclose(file);
return NULL;
}
void *consumer(void *arg) {
int buffer_index = (int)arg;
while (1) {
pthread_mutex_lock(&buffers[buffer_index].mutex);
while (!buffers[buffer_index].ready) {
pthread_cond_wait(&buffers[buffer_index].cond, &buffers[buffer_index].mutex);
}
if (buffers[buffer_index].ready == -1) {
pthread_mutex_unlock(&buffers[buffer_index].mutex);
break;
}
printf("Consumer %d: %s", buffer_index, buffers[buffer_index].data);
buffers[buffer_index].ready = 0;
pthread_cond_signal(&buffers[buffer_index].cond);
pthread_mutex_unlock(&buffers[buffer_index].mutex);
}
return NULL;
}
int main() {
for (int i = 0; i < NUM_BUFFERS; i++) {
pthread_mutex_init(&buffers[i].mutex, NULL);
pthread_cond_init(&buffers[i].cond, NULL);
buffers[i].ready = 0;
}
pthread_t producer_thread;
pthread_create(&producer_thread, NULL, producer, NULL);
pthread_t consumer_threads[NUM_BUFFERS];
for (int i = 0; i < NUM_BUFFERS; i++) {
pthread_create(&consumer_threads[i], NULL, consumer, (void *)i);
}
pthread_join(producer_thread, NULL);
for (int i = 0; i < NUM_BUFFERS; i++) {
pthread_join(consumer_threads[i], NULL);
}
for (int i = 0; i < NUM_BUFFERS; i++) {
pthread_mutex_destroy(&buffers[i].mutex);
pthread_cond_destroy(&buffers[i].cond);
}
return 0;
}
七、实际应用案例
1、读取配置文件
读取配置文件是一个常见的应用场景。配置文件通常包含一系列键值对，每行一个键值对。可以使用逐行读取的方法读取配置文件，并将每个键值对存储在一个数据结构中。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINES 100
#define MAX_LINE_LENGTH 256
typedef struct {
char key[MAX_LINE_LENGTH];
char value[MAX_LINE_LENGTH];
} Config;
int main() {
FILE *file = fopen("config.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
Config configs[MAX_LINES];
int config_count = 0;
char buffer[MAX_LINE_LENGTH];
while (fgets(buffer, sizeof(buffer), file) != NULL && config_count < MAX_LINES) {
char *delimiter = strchr(buffer, '=');
if (delimiter != NULL) {
*delimiter = ' ';
strcpy(configs[config_count].key, buffer);
strcpy(configs[config_count].value, delimiter + 1);
config_count++;
}
}
fclose(file);
// 处理读取的配置
for (int i = 0; i < config_count; i++) {
printf("Key: %s, Value: %s", configs[i].key, configs[i].value);
}
return 0;
}
2、日志文件分析
日志文件分析是另一个常见的应用场景。日志文件通常包含大量的日志记录，每行一条日志记录。可以使用逐行读取的方法读取日志文件，并对每条日志记录进行分析。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINES 1000
#define MAX_LINE_LENGTH 256
typedef struct {
char timestamp[MAX_LINE_LENGTH];
char level[MAX_LINE_LENGTH];
char message[MAX_LINE_LENGTH];
} Log;
int main() {
FILE *file = fopen("log.txt", "r");
if (file == NULL) {
perror("Failed to open file");
return 1;
}
Log logs[MAX_LINES];
int log_count = 0;
相关问答FAQs：
1. 如何使用C语言读取文件的行数据？
C语言提供了多种方法来读取文件的行数据。一种常用的方法是使用标准库函数fgets()。你可以使用fgets()函数逐行读取文件内容，并将每一行存储在一个缓冲区中。
2. 如何处理读取文件行数据时的换行符？
当使用fgets()函数读取文件行数据时，每一行的末尾会包含一个换行符。你可以使用字符串处理函数strcspn()来去除换行符。这个函数可以找到字符串中第一个匹配的字符，并返回其索引。你可以通过将换行符替换为字符串结束符' '来去除换行符。
3. 如何将读取的文件行数据存储到数组中？
要将读取的文件行数据存储到数组中，你需要先定义一个数组来存储行数据。可以使用二维字符数组来存储多行数据，或者使用指针数组来存储每一行的地址。在使用fgets()函数读取每一行数据后，你可以使用strcpy()函数将行数据复制到数组中。记得要根据实际情况分配足够的内存空间来存储行数据。
原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/1201399
