tampon écrit deux fois dans le fichier

Question

J'essaie d'enregistrer des données dans un fichier texte simple en utilisant C. Le problème est que lorsque j'écris le tampon dans le fichier, il est écrit deux fois. Je ne comprends pas pourquoi. J'ai essayé avec fwrite et fputs; même problème, toute aide est la bienvenue.

void addEdge(graph_t *graph, int src, int dest) 
{ 
    FILE *f = fopen("C:\\graph.txt", "a"); 
    if (f == NULL) 
    { 
     printf("Error opening file!\n"); 
     exit(1); 
    } 
    char *c1 =malloc(8* sizeof(char *)),c2[2]="\0"; 
    itoa(src, c1, 10); 
    itoa(dest, c2, 10); 
    /* print some text */ 
    char text[2] = "::"; 
    strcat(c1,text); 
    printf("c1 before %s \n",c1); 
    strcat(c2,"\0"); 
    strcat(c1,c2); 
    printf("c1 after %s ++++++++ c2 %s \n",c1,c2); 

    //fseek(f,0,SEEK_END); 
    //fprintf(f, "%s \n", c1); 
    ///fputs(c1,f); 
    char* pos; 
    pos = strchr(c1, '\0'); 
    int index = (int)(pos - c1); 
    fwrite (c1 , sizeof(char), index , f); 
    fclose(f); 
/**************** some other stuff */ 
} 

L'exécution de ce code devrait me donner cela pour var src = 2 et dest = 18

2::8 

mais dans le fichier que je reçois ce

2::1818 

Answer 1

fopen avec le mode "a" signifie ajouter. Cela signifie que si votre fichier contient des données précédentes, cela restera et tout ce que vous écrivez sera ajouté à la fin. Êtes-vous sûr que ce n'est pas votre problème? Essayez d'utiliser "w" pour remplacer les anciens contenus.

Answer 2

Il y a beaucoup plus de code que nécessaire. Essayez ceci:

void addEdge(graph_t *graph, int src, int dest) 
{ 
    FILE *f = fopen("C:\\graph.txt", "a"); 
    if (f == NULL) 
    { 
     printf("Error opening file!\n"); 
     exit(1); 
    } 
    fprintf(f, "%d::%d", src, dst);  /* <== much simpler, no? */ 
    fclose(f); 
/**************** some other stuff */ 
} 

Answer 3

void addEdge(graph_t *graph, int src, int dest) 
{ 
    FILE *f = fopen("C:\\graph.txt", "a"); 
    if (f == NULL) 
    { 
     printf("Error opening file!\n"); 
     exit(1); 
    } 
    char *c1 =malloc(8* sizeof(char *)),c2[2]="\0"; 

La ligne ci-dessus tente d'allouer 8 octets à c1. Si malloc() échoue, il retournera NULL. La ligne suivante tente d'écrire dans la mémoire allouée, ce qui entraîne une erreur d'exécution "Affectation de pointeur NULL".

itoa(src, c1, 10); 

La ligne ci-dessus n'est pas sûre. La chaîne générée par itoa() peut avoir une longueur maximale de 33 octets (y compris le signe facultatif et la terminaison de terminaison). Le bloc de mémoire attribué pointé par c1 est seulement 8 octets. Dans le pire des cas, itoa() peut dépasser la mémoire allouée en écrasant la mémoire adjacente.

itoa(dest, c2, 10); 

La ligne ci-dessus est encore plus dangereuse; où le tableau c2 [] est seulement deux octets.

/* print some text */ 
    char text[2] = "::"; 

La ligne ci-dessus est un mauvais code. La chaîne "::" équivaut à {':', ':', '\ 0'} qui est trois octets. Le tableau de caractères 'texte' n'a que deux octets. Probablement, cela entraînera l'écriture au-delà de la fin de la chaîne 'texte' d'un octet; entraînant l'écrasement de la mémoire adjacente. Etant donné que la chaîne placée dans c1 peut déjà être plus grande que l'espace alloué, la ligne ci-dessus est tout aussi dangereuse. Étant donné que le texte variable peut ne pas être terminé correctement (étant donné que le terminateur de chaîne se trouve en dehors de l'espace alloué).

printf("c1 before %s \n",c1); 
    strcat(c2,"\0"); 

La ligne ci-dessus n'a aucun intérêt. La chaîne dans le tableau c2 [2] a déjà débordé la mémoire allouée.

strcat(c1,c2); 

La ligne ci-dessus ajoute la valeur c2 du tableau (débordé) à la fin de c1.

printf("c1 after %s ++++++++ c2 %s \n",c1,c2); 

    //fseek(f,0,SEEK_END); 
    //fprintf(f, "%s \n", c1); 
    ///fputs(c1,f); 
    char* pos; 
    pos = strchr(c1, '\0'); 
    int index = (int)(pos - c1); 
    fwrite (c1 , sizeof(char), index , f); 
    fclose(f); 
/**************** some other stuff */ 
} 

---

Ne connaissant pas le but exact, voici une tentative de réécriture:

void addEdge(graph_t *graph, int src, int dest) 
    { 
    FILE *f = NULL; 

    errno=0;       /* Requires the header 'errno.h' */ 
    f = fopen("C:\\graph.txt", "a"); 
    if(NULL == f) 
     { 
     printf("Error opening file! errno[%d]\n", errno); 
     exit(1); 
     } 

    /* print some text */ 
    fprintf(f, "%d::%d", dest, src); 
    fclose(f); 
/**************** some other stuff */ 
}