C语言 fgets while循环第二次出错？

Question

C语言 fgets while循环第二次出错？

Ethan_liang

35

发布于
2022-08-07 广西桂林市

更新于
2022-08-08

新手上路，请多包涵

题目描述

程序运行后，在linux终端获取一个整形数字，在log文件中保存，保存格式为 [年-月-日时:分:秒]get_num = [数字]\n，如：
[ 2022-08-07 14:16:23 ] get_num= 1
要求：1.文件最多保存的log数量为10条当有第11条log的时候应该覆盖第1条log
假如第11次输入值为4，文件内容为：
[年-月-日时:分:秒] get_num= 4
[年-月-日时:分:秒] get_num= 1
[年-月-日时:分:秒] get_num= 2
...
[年-月-日时:分:秒] get_num= 2

要求二：再次进入文件log保存功能时当文件存在的时候应该也往后追加
如上一次退出log保存功能时文件内容为：
[年-月-日时:分:秒] get_num= 4
[年-月-日时:分:秒] get_num= 1
[年-月-日时:分:秒] get_num= 2
...
[年-月-日时:分:秒] get_num= 2
再次进入文件log保存功能输入值为5 此时文件的内容为：
[年-月-日时:分:秒] get_num= 4
[年-月-日时:分:秒] get_num= 5
[年-月-日时:分:秒] get_num= 1
[年-月-日时:分:秒] get_num= 2
...
[年-月-日时:分:秒] get_num= 2

自己的思路

我是用fgets函数获取时间保存到数组里，然后遍历寻找最小值，再把最新的数据插入到最小值所在的行数中

相关代码

读取相关代码如下：

dataType log_Load()
{
    FILE *fp;
    
    dataType  time = 0;
    dataType  ret = 0;
    dataType  load_date[128]  = {0};
    dataType  load_time[128]  = {0};

    char *p;
    char str_temp[512] = {"0"};
    char date_tmp[128] = {"0"};
    char time_tmp[128] = {"0"};
    // log_que = calloc(1, 1024);
    // P_Queue date = (P_Queue) log_que;
    
    printf("reloading...\n");
    
    dataType n = 0;

    fp = fopen(LOGPATH, "r+");
       
    // char buff[512] ;

    // printf("%d\n",__LINE__);
    // memset(linebuffer, 0, sizeof(linebuffer));
   

    /* 读取log文件数据 */

 char *buff = (char *)malloc(64 * 64);

    while ( !feof(fp) )
    {
        printf("%d\n",__LINE__);
        p = fgets(buff, 63, fp);

        if ( NULL == p ) {
            perror("fgets error>>>>>>");
        }
        printf("%s\n",buff);
        printf("%d\n",__LINE__);
        sscanf(buff, "%s %s %s", str_temp, date_tmp, time_tmp);
        printf("str_temp:%s, date_tmp:%s, time_tmp:%s\n ", str_temp, date_tmp, time_tmp);

        date_tmp[strlen(date_tmp)] = delchar(date_tmp, '-');
        time_tmp[strlen(time_tmp)] = delchar(time_tmp, ':');
        // printf("date_tmp:%s,time_tmp:%s\n", date_tmp, time_tmp);

        sscanf(date_tmp, "%d",  &(load_date[n]));
        sscanf(time_tmp, "%d",  &(load_time[n]));
        // printf("date_tmp:%d,time_tmp:%d\n", load_date[n], load_time[n]);

        n ++;

        memset(buff, 0, sizeof(buff));
    }
    // for(size_t i; i < QUEUEMAX; i++){
    //     // memset(linebuffer, 0, sizeof(linebuffer[n]));
    //     fgets(buff, sizeof(buff)-1 , fp);
    //     printf("%d\n",__LINE__);
    //     memset(str_temp, 0, sizeof(str_temp));
    //     memset(date_tmp, 0, sizeof(date_tmp));
    //     memset(date_tmp, 0, sizeof(time_tmp));
    //     printf("%d\n",__LINE__);
    //     printf("linebuffer: %s\n", buff);
    //     sscanf(buff, "%s %s %s", str_temp, date_tmp, time_tmp);
    //     printf("str_temp:%s, date_tmp:%s, time_tmp:%s\n ", str_temp, date_tmp, time_tmp);
    //     n ++;

    //     date_tmp[strlen(date_tmp)] = delchar(date_tmp, '-');
    //     time_tmp[strlen(time_tmp)] = delchar(time_tmp, ':');
    //     printf("date_tmp:%s,time_tmp:%s\n", date_tmp, time_tmp);

    //     sscanf(date_tmp, "%d",  &(load_date[n]));
    //     sscanf(time_tmp, "%d",  &(load_time[n]));
            
    //     printf("%d\n",__LINE__);

    //     if (feof(fp) )
    //     {
    //         fclose(fp);
    //         memset(buff, 0, sizeof(buff));
    //     } 
        
    // }

   
    
    
    // while (fgets(buff, 63, fp))
    // {
    //     printf("%s\n",buff);
    //     printf("%d\n",__LINE__);
    //     sscanf(buff, "%s %s %s", str_temp, date_tmp, time_tmp);
    //     printf("str_temp:%s, date_tmp:%s, time_tmp:%s\n ", str_temp, date_tmp, time_tmp);

    //     date_tmp[strlen(date_tmp)] = delchar(date_tmp, '-');
    //     time_tmp[strlen(time_tmp)] = delchar(time_tmp, ':');
    //     // printf("date_tmp:%s,time_tmp:%s\n", date_tmp, time_tmp);

    //     sscanf(date_tmp, "%d",  &(load_date[n]));
    //     sscanf(time_tmp, "%d",  &(load_time[n]));
    //     // printf("date_tmp:%d,time_tmp:%d\n", load_date[n], load_time[n]);

    //     n ++;

    //     memset(buff, 0, sizeof(buff));
    // }

    free(buff);
    ret = fclose(fp);
    if ( EOF == ret)
    {
        perror("fclose error>>>>");
    }
    

    int min=0 , cnt = 0;


    for (size_t i = 1; i < QUEUEMAX; i++){
        /* 从第二位数开始判断 */
        if(load_date[i] < load_date[min]){
            min = i;    
            cnt ++;
        }
        printf("load_date min:%d\n", min);
    }
    // printf("cnt:%d\n", cnt);
    if (0 == cnt) {
         for (size_t i = 1; i < QUEUEMAX; i++){
        /* 从第二位数开始判断 */
            if(load_time[i] < load_time[min]){
                min = i;    
            }
            // printf("load_time min:%d\n", min);
        }
        printf("最小值为:%d,下标为：%d",load_time[min],min);
        printf("\nDone\n");
        return min;
    }
    
    printf("最小值为:%d,下标为：%d",load_date[min],min);
    printf("\nDone\n");
    return min;  
}

完整代码如下：

/*
 * @Descripttion   : log function
 * @Author         : Ethan.liang
 * @Date           : 2022-07-18 09:20:36
 * @LastEditors:    
 * @LastEditTime: 2022-07-25 03:23:38
 */
#include <time.h>
#include <sys/time.h>
#include "log.h"

dataType log_ret = -1;
dataType log_num = -1;
dataType log_cnt = 1;
dataType log_index = 0;
dataType log_sel = -1;
dataType line_len = 0;
dataType len = 0;

char str_temp[512] = {0};
char Date[512] = {0};

char linebuffer[QUEUEMAX][128]= {0};

#define LOGPATH "../log.txt"




/**
 * @name         : QueueInit
 * @brief        :  初始化队列
 * @param         {P_Queue} log_que
 * @return        {P_Queue} log_que
 */
P_Queue QueueInit(P_Queue log_que)
{
    assert(log_que);                        //判断指针的有效性
                                            // log_que->_head->_index = 1;
    log_que->_head = log_que->_tail = NULL; //队头和队尾指向空指针

    return log_que;
}



/**
 * @name         : QueueDestory
 * @brief        : 销毁队列
 * @param         {P_Queue} log_que
 * @return        {P_Queue}log_que
 */
P_Queue QueueDestory(P_Queue log_que)
{
    assert(log_que);
    QueueNode *cur = log_que->_head;
    while (cur)
    {
        QueueNode *next = cur->_next;
        free(cur);
        cur = next;
    }
    log_que->_head = log_que->_tail = NULL;

    return log_que;
}


/**
 * @name         : QueuePush
 * @brief        : 入队
 * @param         {P_Queue} log_que
 * @param         {dataType} log_num
 * @return        {P_Queue}log_que
 * @note         : 有BUG，入队时QueuePush写入index会导致QueueInit失败，只能在QueuePush函数外赋值，可能QueueInit写得有点问题
 */
P_Queue QueuePush(P_Queue log_que, dataType log_num)
{
    assert(log_que);
    P_Node newnode = (P_Node)malloc(sizeof(P_Node)); //为新节点申请内存空间
    if (newnode == NULL)                             //判断内存空间是否申请成功
    {
        printf("内存不足!\n");
        exit(-1);
    }

    
    newnode->_data = log_num;   //新节点储存数据
    newnode->_next = NULL;      //新节点的下一个指向NULL，即新节点作为队尾
    if (log_que->_head == NULL) //将新节点入队
    {
        log_que->_head = log_que->_tail = newnode;
    }
    else
    {
        log_que->_tail->_next = newnode;
        log_que->_tail = newnode;
    }

    // free(newnode);
    return log_que;
}



/**
 * @name         : QueuePop
 * @brief        : 出队
 * @param         {P_Queue} log_que
 * @return        {P_Queue} log_que
 */
P_Queue QueuePop(P_Queue log_que)
{
    assert(log_que);
    assert(log_que->_head);

    if (log_que->_head == NULL)
    {
        // printf("%d\n",__LINE__);
        free(log_que->_head);
        log_que->_head = log_que->_tail = NULL;
    }
    else
    {
        QueueNode *next = log_que->_head->_next;
        // printf("%d\n",__LINE__);

        free(log_que->_head);
        // printf("%d\n",__LINE__);
        log_que->_head = next;
    }
    // printf("%d\n",__LINE__);

    
    return log_que;
}


/**
 * @name         : QueueFront
 * @brief        : 访问队首的元素
 * @param         {Queue} *log_que
 * @return        {Queue}  *(log_que->_head->_data)
 */
dataType QueueFront(Queue *log_que)
{
    assert(log_que);
    assert(log_que->_head);
    return log_que->_head->_data;
}

/**
 * @name         : QueueBack
 * @brief        : 访问队尾的元素
 * @param         {Queue} *log_que
 * @return        {Queue}  *(log_que->_tail->_data)
 */
dataType QueueBack(Queue *log_que)
{
    assert(log_que);
    assert(log_que->_tail);
    return log_que->_tail->_data;
}

/**
 * @name         : QueueEmpty
 * @brief        : 返回1是空，返回0是非空
 * @param         {Queue} *log_que
 * @return        1 --> log_que->_head == NULL,0 --> log_que->_head != NULL
 */
dataType QueueEmpty(Queue *log_que)
{
    assert(log_que);
    return log_que->_head == NULL ? 1 : 0;
}

// 获取数据的个数
/**
 * @name         : QueueSize
 * @brief        : 获取数据的个数
 * @param         {Queue} *log_que
 * @return        {int} size
 */
dataType QueueSize(Queue *log_que)
{
    assert(log_que);
    QueueNode *cur = log_que->_head;
    int size = 0;
    while (cur)
    {
        ++size;
        cur = cur->_next;
    }
    return size;
}

char delchar( char *str, char c )
{
    int i,j;
    for(i=j=0;str[i]!='\0';i++) {
        //判断是否有和待删除字符一样的字符
        if(str[i]!=c) {
            str[j++]=str[i];
        }
    }
    str[j]='\0';//字符串结束

    return *str;
}

/**
 * @name         : log_Load
 * @brief        : 加载log文件
 * @param         {dataType} log_index
 * @return        {int} log_index
 */
dataType log_Load()
{
    FILE *fp;
    
    dataType  time = 0;
    dataType  ret = 0;
    dataType  load_date[128]  = {0};
    dataType  load_time[128]  = {0};

    char *p;
    char date_tmp[128] = {"0"};
    char time_tmp[128] = {"0"};
    // log_que = calloc(1, 1024);
    // P_Queue date = (P_Queue) log_que;
    
    printf("reloading...\n");
    
    dataType n = 0;

    fp = fopen(LOGPATH, "r+");
       
    // char buff[512] ;

    // printf("%d\n",__LINE__);
    // memset(linebuffer, 0, sizeof(linebuffer));
   

    /* 读取log文件数据 */
    // for(size_t i; i < QUEUEMAX; i++){
    //     // memset(linebuffer, 0, sizeof(linebuffer[n]));
    //     fgets(buff, sizeof(buff)-1 , fp);
    //     printf("%d\n",__LINE__);
    //     memset(str_temp, 0, sizeof(str_temp));
    //     memset(date_tmp, 0, sizeof(date_tmp));
    //     memset(date_tmp, 0, sizeof(time_tmp));
    //     printf("%d\n",__LINE__);
    //     printf("linebuffer: %s\n", buff);
    //     sscanf(buff, "%s %s %s", str_temp, date_tmp, time_tmp);
    //     printf("str_temp:%s, date_tmp:%s, time_tmp:%s\n ", str_temp, date_tmp, time_tmp);
    //     n ++;

    //     date_tmp[strlen(date_tmp)] = delchar(date_tmp, '-');
    //     time_tmp[strlen(time_tmp)] = delchar(time_tmp, ':');
    //     printf("date_tmp:%s,time_tmp:%s\n", date_tmp, time_tmp);

    //     sscanf(date_tmp, "%d",  &(load_date[n]));
    //     sscanf(time_tmp, "%d",  &(load_time[n]));
            
    //     printf("%d\n",__LINE__);

    //     if (feof(fp) )
    //     {
    //         fclose(fp);
    //         memset(buff, 0, sizeof(buff));
    //     } 
        
    // }

    char *buff = (char *)malloc(64 * 64);

    while ( !feof(fp) )
    {
        printf("%d\n",__LINE__);
        p = fgets(buff, 63, fp);

        if ( NULL == p ) {
            perror("fgets error>>>>>>");
        }
        printf("%s\n",buff);
        printf("%d\n",__LINE__);
        sscanf(buff, "%s %s %s", str_temp, date_tmp, time_tmp);
        printf("str_temp:%s, date_tmp:%s, time_tmp:%s\n ", str_temp, date_tmp, time_tmp);

        date_tmp[strlen(date_tmp)] = delchar(date_tmp, '-');
        time_tmp[strlen(time_tmp)] = delchar(time_tmp, ':');
        // printf("date_tmp:%s,time_tmp:%s\n", date_tmp, time_tmp);

        sscanf(date_tmp, "%d",  &(load_date[n]));
        sscanf(time_tmp, "%d",  &(load_time[n]));
        // printf("date_tmp:%d,time_tmp:%d\n", load_date[n], load_time[n]);

        n ++;

        memset(buff, 0, sizeof(buff));
    }
    
    
    // while (fgets(buff, 63, fp))
    // {
    //     printf("%s\n",buff);
    //     printf("%d\n",__LINE__);
    //     sscanf(buff, "%s %s %s", str_temp, date_tmp, time_tmp);
    //     printf("str_temp:%s, date_tmp:%s, time_tmp:%s\n ", str_temp, date_tmp, time_tmp);

    //     date_tmp[strlen(date_tmp)] = delchar(date_tmp, '-');
    //     time_tmp[strlen(time_tmp)] = delchar(time_tmp, ':');
    //     // printf("date_tmp:%s,time_tmp:%s\n", date_tmp, time_tmp);

    //     sscanf(date_tmp, "%d",  &(load_date[n]));
    //     sscanf(time_tmp, "%d",  &(load_time[n]));
    //     // printf("date_tmp:%d,time_tmp:%d\n", load_date[n], load_time[n]);

    //     n ++;

    //     memset(buff, 0, sizeof(buff));
    // }

    free(buff);
    ret = fclose(fp);
    if ( EOF == ret)
    {
        perror("fclose error>>>>");
    }
    

    int min=0 , cnt = 0;


    for (size_t i = 1; i < QUEUEMAX; i++){
        /* 从第二位数开始判断 */
        if(load_date[i] < load_date[min]){
            min = i;    
            cnt ++;
        }
        printf("load_date min:%d\n", min);
    }
    // printf("cnt:%d\n", cnt);
    if (0 == cnt) {
         for (size_t i = 1; i < QUEUEMAX; i++){
        /* 从第二位数开始判断 */
            if(load_time[i] < load_time[min]){
                min = i;    
            }
            // printf("load_time min:%d\n", min);
        }
        printf("最小值为:%d,下标为：%d",load_time[min],min);
        printf("\nDone\n");
        return min;
    }
    
    printf("最小值为:%d,下标为：%d",load_date[min],min);
    printf("\nDone\n");
    return min;  
}

/**
 * @name         : log_index
 * @brief        : 保存log文件
 * @param         {P_Queue} log_que
 * @return        {P_Queue} log_que
 */
P_Queue log_save(P_Queue log_que)
{
    struct timeval      tv_log;
    struct  tm         *tm_ptr;

    char date_tmp[128] = {"0"};
    char time_tmp[128] = {"0"};       

    gettimeofday(&tv_log, NULL);
 
    tm_ptr = localtime(&tv_log.tv_sec);

    printf("请输入要保存的数:\n");
    log_ret = scanf("%d", &log_num);
    if (log_ret)
    {
        getchar();
    }
    else
    {
        printf("请输入数字!\n");

        return 0;
    }

    

    FILE *fp;
    fp = fopen(LOGPATH, "r");
    if (NULL == fp)
    {
        perror("open log.txt error>>>");
        exit(1);
    }
    printf("%d\n",__LINE__);

    dataType n = 0;
    if (1 == log_cnt)
    {
        /* code */
        while ( fgets(linebuffer[n], MAX_DATA, fp) )
        {

            n ++;
            log_cnt = n;
            printf("log_cnt:%d\n", log_cnt);
            
        }
        printf("line:%d\n",__LINE__);
    }
    
    fclose(fp);

    if (log_cnt < QUEUEMAX)
    {

        QueuePush(log_que, log_num);
        // printf("%d\n",__LINE__);
        // getchar();
        // printf("%d\n",__LINE__);
        // strncpy(log_que->_tail->_time, Date, sizeof(Date));
        // printf("%d\n",__LINE__);
        // printf("Date:%s\n", log_que->_tail->_time);
        // printf("%d\n",__LINE__);

        log_index = log_Load(log_que);

        printf("log_index:%d\n", log_index);
        
        log_que->_tail->_index = log_index+1;
        log_que->_tail->_data = log_num;

        printf("%d\n",__LINE__);

        memset(time_tmp, 0 , sizeof(time_tmp));
        snprintf(time_tmp, sizeof(time_tmp) ,
            "[ %d-%02d-%02d %02d:%02d:%02d ]",
            1900+tm_ptr->tm_year, 1+tm_ptr->tm_mon, tm_ptr->tm_mday, 
            tm_ptr->tm_hour, tm_ptr->tm_min, tm_ptr->tm_sec);
        // printf("len:%ld\n", strlen(time_tmp));
        printf("date:%s\n", time_tmp);

        
        sprintf(str_temp, "echo  '%s get_num= %d' >> %s ", time_tmp, log_que->_tail->_data, LOGPATH);
        
        system(str_temp);
        memset(str_temp, 0, sizeof(str_temp));
        // printf("QueueBack:%d, num:%d\n ", log_que->_tail->_index, QueueBack(log_que));
        // printf("QueueFront:%d, num:%d\n", log_que->_head->_index, QueueFront(log_que));

        // log_cnt++;

        // fclose(fp);
        
    }
    else
    {
        log_index = log_Load(log_que);

        
        //读打开原文件
        // fp = fopen(LOGPATH, "r");
        // if (NULL == fp)
        // {
        //     perror("open log.txt error>>>");
        //     exit(1);
        // }

        // //写打开临时文件
        // fpt = fopen("../log_tmp.txt", "w");
        // if (NULL == fp)
        // {
        //     perror("open log_tmp.txt error>>>");
        //     exit(1);
        // }

        QueuePush(log_que, log_num);
        QueuePop(log_que);

        /* 保存元素到队列 */
        log_que->_tail->_index = log_index + 1;
        log_que->_tail->_data = log_num;

        printf("log_index:%d\n", log_que->_tail->_index);

        memset(time_tmp, 0 , sizeof(time_tmp));
        snprintf(time_tmp, sizeof(time_tmp) ,
            "[ %d-%02d-%02d %02d:%02d:%02d ]",
            1900+tm_ptr->tm_year, 1+tm_ptr->tm_mon, tm_ptr->tm_mday, 
            tm_ptr->tm_hour, tm_ptr->tm_min, tm_ptr->tm_sec);
        printf("len:%ld\n", strlen(time_tmp));
        printf("date:%s\n", time_tmp);

        // sprintf(str_temp, "sed  '%s get_num= %d' >> %s ", time_tmp, log_que->_tail->_data, LOGPATH);
        sprintf(str_temp, "  sed -i '%dc %s get_num= %d ' %s ",log_que->_tail->_index , time_tmp, log_que->_tail->_data, LOGPATH);
        printf("str_temp = %s\n", str_temp);
        system(str_temp);
        memset(str_temp, 0, sizeof(str_temp));

        // /* 从源文件读取一行 */
        // dataType n=0;
        // while ( fgets(linebuffer[n], MAX_DATA, fp) )
        // {
        //     n ++;
        // }
        // fclose(fp);

        /* 取index个位 */
        // dataType idex_ones ;
        // if (0 == (log_que->_tail->_index % 10) )
        // {
        //     idex_ones = QUEUEMAX;
        // }
        // else
        // idex_ones = log_que->_tail->_index % 10;

        /* 将结果保存到数组中 */
        // snprintf(str_temp, sizeof(str_temp), "%d get_num= %d\n", 
        //     log_que->_tail->_index, log_que->_tail->_data);

        // /* 插入数据 */
        // strcpy(linebuffer[(idex_ones - 1)], str_temp);

        // for (int i = 0; i < n; i++)
        // {
        //     fputs(linebuffer[i], fpt);
        // }
        
        // fclose(fpt);

        // remove("../log.txt");

        // rename("../log_tmp.txt", "../log.txt" );

        

       
    }

    return log_que;
}

/* 打印log */
/**
 * @name         : log_Display
 * @brief        : 打印log
 */
dataType log_Display()
{
    int n = 0;
    

    FILE *fp = fopen(LOGPATH, "r");
    if (NULL == fp)
    {
        perror("open log.txt error>>>");
        exit(1);
    }

    dataType  index_read = 0;
    dataType  num_read   = 0;

    /* 查找队头*/
    log_index = ( (log_Load(log_index) - 9) );

    printf("log_index:%d\n", log_index);
    while ( fgets(linebuffer[0], MAX_DATA, fp) )
    {
        log_ret = ftell(fp);
        printf("ftell:%d\n", log_ret);
        line_len = strlen(linebuffer[0]);
        // len += line_len;
        // printf("%d\n",__LINE__);
        // printf("linebuffer:%s\n", linebuffer[n]);
        
        sscanf(linebuffer[0], "%d %s %d", &index_read, str_temp, &num_read);
        printf("index_read:%d ,num_read:%d\n", index_read, num_read);
        
        // printf("ftell:%ld\n", ftell(fp));
    
        
        if ( log_index ==  index_read)
        {   

            break;
            
        }
        sleep(1);
        n ++;
    }

    

    log_ret = ftell(fp);
    printf("ftell:%d\n", log_ret);

    memset(linebuffer, 0 , sizeof(linebuffer));
    fseek(fp, -line_len, SEEK_CUR);
    
    /* 打印log */
    for (int i = 0; i <= QUEUEMAX ; i++)
    {
        
        fgets(linebuffer[i], MAX_DATA, fp);

        printf("%s\n", linebuffer[i]);
        
        if ( feof(fp) )
        {
            fseek(fp, 0 , SEEK_SET);
        }
        
        n ++;
    }
    
    
    fclose(fp);
    
}

/**
 * @name         : log_window
 * @brief        : log加载界面
 * @return        {*}
 */
dataType log_window()
{
    // system("clear");
    printf("|***********log功能界面************|\n");
    printf("|       1:文件保存log功能          |\n");
    printf("|       2:文件log打印功能          |\n");
    printf("|       0:返回上一级菜单           |\n");
    printf("|**********************************|\n");
}

/**
 * @name         : log_function
 * @brief        : log功能调用函数， main函数调用
 * @param         {P_Queue} log_que
 * @return        0
 */
int log_function(P_Queue log_que)
{
    
    // P_Queue log_que = calloc(1, sizeof(P_Queue));
    // QueueInit(log_que);

    dataType log_sel = -1;

    while (1)
    {
        log_window();

        log_ret = scanf("%d", &log_sel);
        if (-1 == log_ret)
        {
            printf("请重新输入!\n");
            return log_ret;
        }
        else
        {
            getchar();
        }
        printf("puts:%d\n", log_sel);

        switch (log_sel)
        {
            case 1:
                log_save(log_que);
                break;

            case 2:
                log_Display();
                
                break;

            default:

                return 0;
        }
    }

    // QueueDestory(log_que);
    // return 0;
}



int main(int argc, char const *argv[])
{

    P_Queue log_que = calloc(1, 1024);
    // P_Queue log_que ;
    QueueInit(log_que);

    log_function(log_que);

    QueueDestory(log_que);

    
    return 0;
}

/*
 * @Descripttion   : 
 * @Author         : Ethan.liang
 * @Date           : 2022-07-24 21:17:28
 * @LastEditors    : Do not Edit
 * @LastEditTime   : 2022-08-06 19:01:21
 */
#ifndef     __LOG_H__
#define        __LOG_H__

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <time.h>


typedef int  dataType;

#define QUEUEMAX 10
#define MAX_DATA 1024

// char log_buffer[100][1024] = {0};
typedef struct QueueNode
{
    dataType _data; //用来存储数据
    dataType _index;

    char    _time[512];
    
    
    struct QueueNode *_next; //用来指向下一个结构体
} QueueNode, *P_Node;

typedef struct Queue
{
    QueueNode *_head; //存放整个队列的队头
    QueueNode *_tail; //存放整个队列的队尾
} Queue, *P_Queue;

//初始化
P_Queue QueueInit(P_Queue log_que);

//销毁
P_Queue QueueDestory(P_Queue log_que);

//入队
P_Queue QueuePush(P_Queue log_que, dataType log_num);

//出队
P_Queue QueuePop(P_Queue log_que);

//访问队首的元素
dataType QueueFront(Queue *log_que);

//访问对尾的元素
dataType QueueBack(Queue *log_que);

//返回1是空，返回0是非空
dataType QueueEmpty(Queue *log_que);

//获取数据的个数
dataType QueueSize(Queue *log_que);

// 读取log文件
dataType log_Load();

// 保存log文件
P_Queue log_save(P_Queue log_que);

// log加载界面
dataType log_window();

// 
dataType log_Display();

int log_function(P_Queue log_que);

#endif

实际看到的错误信息是什么？

我在其他函数调用log_load函数时，第一次可以正常调用，但是但再次调用log_load时，直接报出
segmentfault

用了GDB看core文件，结果如下

由于本人水平有限，看不出来哪里出了问题，想问问大神们应该怎样解决T~T

c linux编程

阅读 1.2k

1 个回答

得票最新

瞿小凯

1.3k1613

发布于
2023-07-14 四川

不知道这个一年前的问题楼主是否想明白了，这个问题，不注意拿着代码去调试，还真不容易发现问题在哪儿。
这个问题是部分变量的设定导致了内存分配问题，具体说就是你设定的一个叫log_Load()的函数中。使用了一个指向动态分配内存的局部变量buff。每次调用log_Load()函数时，buff变量都会重新分配内存，但您在函数结束之后没有释放这块内存。因此，当再次调用log_Load()函数时，可能会导致内存分配错误，进而引发段错误。把部分改到全局里面，然后free释放应该就没问题。

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

#define MAX_BUFFER_SIZE 64 * 64

// 全局变量
char buff[MAX_BUFFER_SIZE];

dataType log_Load()
{
    // 读取log文件数据
    FILE *fp = fopen(LOGPATH, "r+");
    if (fp == NULL) {
        perror("无法打开文件\n");
        return -1;
    }

    dataType load_date[128] = {0};
    dataType load_time[128] = {0};
    dataType n = 0;
    
    while (!feof(fp)) {
        if (fgets(buff, MAX_BUFFER_SIZE, fp) == NULL) {
            perror("读取文件失败\n");
            fclose(fp);
            return -1;
        }
        
        char str_temp[512], date_tmp[128], time_tmp[128];
        
        sscanf(buff, "%s %s %s", str_temp, date_tmp, time_tmp);
        
        date_tmp[strlen(date_tmp)] = delchar(date_tmp, '-');
        time_tmp[strlen(time_tmp)] = delchar(time_tmp, ':');
        
        sscanf(date_tmp, "%d", &load_date[n]);
        sscanf(time_tmp, "%d", &load_time[n]);
        
        n++;
    }
    
    fclose(fp);

    // 释放内存
    memset(buff, 0, MAX_BUFFER_SIZE);

    // 继续处理其他逻辑
    // ...
}

int main()
{
    log_Load();
    return 0;
}

撰写回答

你尚未登录，登录后可以

和开发者交流问题的细节
关注并接收问题和回答的更新提醒
参与内容的编辑和改进，让解决方法与时俱进

推荐问题

相似问题

找不到问题？创建新问题

C语言 fgets while循环第二次出错？

题目描述

自己的思路

相关代码

实际看到的错误信息是什么？

你尚未登录，登录后可以

pkg-config编译安装时提示需要glib库的支持？

迟到问题，知道其他解法，但是想探求为什么以下解法不行？