Discussion :

[hamidou sow]

Bonjour,

J'aimerais avoir votre aide pour la suppression dune ligne dans un fichier txt....je n'arrive pas à supprimer le fichier original pour le remplacer par mon fichier temporaire.
voici mon code pour la suppression d'une ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
void Supprimer_etud()
    {
                 string MON_FICHIER("D:/MON_FICHIER_APPL/FICHIER.txt");
        ifstream flux(MON_FICHIER.c_str());//fichier contenant la ligne a supp
            string MON_TAMPON("D:/MON_FICHIER_APPL/TAMPON.txt");
        ofstream flux1(MON_TAMPON.c_str(),ios::app);  //fichier tamporaire pour garder le contenu du fichier original excepte de la ligne a supprimer
 
            int pos;
        if(flux)
        {
               bool test;
               string ligne,copie_ligne,chaine;
               cout<<"donner le matricule : ";getline(cin,chaine);
               getline(cin,chaine);
 
               test=Rechercher_etud(chaine,copie_ligne);
 
               if(test)
               {
 
                    if(flux1)
                        {
 
 
 
 
                            while(getline(flux,ligne))
                                {
                                    if(ligne==copie_ligne)
                                    {
                                        cout<<"ligne retrouver suppression en cour "<<endl;
                                        continue;
                                    }
                                    else
                                    {
 
                                        flux1.seekp(0,ios::end);
                                        int j=flux1.tellp();
                                            if(j==0)
                                                {
                                                    EN_TETE(MON_FICHIER);
                                                    flux1<<ligne<<endl;
 
                                                }
                                                else
                                                    {
                                                        flux1<<ligne<<endl;
                                                    }
 
                                    }
                                }
                        }
                        else{cout<<"erreure douverture du fichier flux1 "<<endl;}
 
 
                }
                else{cout<<"le matricule n\'existe pas "<<endl;}
 
 
 
        }
        else
        {
            cout<<endl<<"ERREURE DOUVERTURE DU FICHIER"<<endl;
        }
        remove("FICHIER.txt");
        rename("TAMPON.txt","FICHIER.txt");
 
 
 
    }

[imperio]

Au lieu de creer un fichier temporaire, tu ferais mieux de juste stocker ton fichier dans une string. Apres tu re-ouvres le fichier en mode ecriture | truncate et tu reecris sans la ligne que tu veux supprimer.

[hamidou sow]

eh bien pour la reecriture dans mon fichier de la string est ce je doit parcourir ligne par ligne la variable string qui contien le fichier ?

[JolyLoic]

Au lieu de creer un fichier temporaire, tu ferais mieux de juste stocker ton fichier dans une string. Apres tu re-ouvres le fichier en mode ecriture | truncate et tu reecris sans la ligne que tu veux supprimer.

Je préfère largement un code qui travaille sur un fichier temporaire que sur le vrai fichier. C'est un peu le principe du commit or rollback, ou encore de la strong exception safety, appliqué aux fichiers. Dans ce que tu proposes, que se passe-t-il en cas de coupure de courant au début de la seconde étape ? On a perdu des données. Alors que dans l'algorithme initial, on a toujours les données disponibles quelquepart (en supposant rename atomique, mais on peut remplacer ce rename par une copie suivie d'un effacement pour être certain de ne pas avoir de soucis).

Et au delà de ça, cette technique marche aussi pour des fichiers très gros qui ne tiendraient pas en mémoire vive.

[JolyLoic]

Si je simplifie ton code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
void Supprimer_etud()
    {
                 string MON_FICHIER("D:/MON_FICHIER_APPL/FICHIER.txt");
        ifstream flux(MON_FICHIER.c_str());//fichier contenant la ligne a supp
            string MON_TAMPON("D:/MON_FICHIER_APPL/TAMPON.txt");
        ofstream flux1(MON_TAMPON.c_str(),ios::app);  //fichier tamporaire pour garder le contenu du fichier original excepte de la ligne a supprimer
        // autres opérations
        remove("FICHIER.txt");
        rename("TAMPON.txt","FICHIER.txt");
    }

On voit que tu essayes de supprimer/renommer les fichiers alors que des variables de type stream lisant/écrivant ces mêmes fichiers sont encore vivantes et actives, et donc empêchent de les renommer/effacer. Il faut donc au préalable fermer ces flux (flux.close()), ou mieux, détruire ces variables :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void Supprimer_etud()
{
    {   // Scope créé pour gérer la durée de vie de flux et flux1
        string MON_FICHIER("D:/MON_FICHIER_APPL/FICHIER.txt");
        ifstream flux(MON_FICHIER.c_str());//fichier contenant la ligne a supp
        string MON_TAMPON("D:/MON_FICHIER_APPL/TAMPON.txt");
        ofstream flux1(MON_TAMPON.c_str(),ios::app);  //fichier tamporaire pour garder le contenu du fichier original excepte de la ligne a supprimer
        // autres opérations
    } // Ici, ils sont détruits
    remove("FICHIER.txt");
    rename("TAMPON.txt","FICHIER.txt");
}

[hamidou sow]

Bonsoir, je viens d'essayer à nouveau avec mon fichier mais, j'ai toujours le même problème car le fichier original n'est toujours pas supprimé et le fichier tampon n'est pas renommé
Pouvez-vous m'aider ?

[imperio]

Je préfère largement un code qui travaille sur un fichier temporaire que sur le vrai fichier. C'est un peu le principe du commit or rollback, ou encore de la strong exception safety, appliqué aux fichiers.
Et au delà de ça, cette technique marche aussi pour des fichiers très gros qui ne tiendraient pas en mémoire vive.

Je ne suis pas tout a fait d'accord avec toi. Pour l'utilisation d'un fichier temporaire, il y a cette fonction pour commencer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
#include <cstdio>
 
FILE* tmpfile();

Et je ne vois pas l'interet de s'en servir a part si on doit manipuler de grosses quantites d'informations. Si ce n'est pas le cas, je trouve l'utilisation d'un type adapte (une string par exemple ou bien un vector<string> avec un element du vector = une ligne du fichier) beaucoup plus elegante.

Dans ce que tu proposes, que se passe-t-il en cas de coupure de courant au début de la seconde étape ? On a perdu des données. Alors que dans l'algorithme initial, on a toujours les données disponibles quelquepart (en supposant rename atomique, mais on peut remplacer ce rename par une copie suivie d'un effacement pour être certain de ne pas avoir de soucis).

Dans ce cas-la, l'ecriture dans le fichier "temporaire" (donc pas creer avec tmpfile) peut aussi echouer et ainsi rendre les donnees illisibles. Je pense donc qu'il vaut mieux reprendre le traitement depuis le debut meme si une fois de plus, si les donnees manipulaient sont tres lourdes, ta solution est la mieux.

[JolyLoic]

Je suis d'accord pour dire qu'il y a de meilleures manière pour créer un fichier temporaire en C++. Le problème étant qu'il n'y en a aucune qui soit vraiment bonne (par exemple, tmpfile retorune un FILE*, pas un flux).

Dans ce cas-la, l'ecriture dans le fichier "temporaire" (donc pas creer avec tmpfile) peut aussi echouer et ainsi rendre les donnees illisibles. Je pense donc qu'il vaut mieux reprendre le traitement depuis le debut meme si une fois de plus, si les donnees manipulaient sont tres lourdes, ta solution est la mieux.

Oui, mais si l'écriture dans le fichier temporaire échoue, on a toujours accès au fichier initial. Alors que si on travaille en mémoire et qu'on écrit directement dans le fichier, on risque de n'avoir en cas de problème ni le fichier initial, ni le fichier final.

[jblecanard]

Je soutiens JolyLoïc sur la méthode d'écriture du fichier, celle qu'il propose est bien plus fiable. Stocker tout le fichier en mémoire n'a rien de particulièrement élégant, surtout dès qu'on commence à traiter de gros fichiers. Si en plus on écrit des services qui doivent tourner 24h/24 et résister aux pannes, la mise en RAM pour écrire ensuite est tout simplement inacceptable.

[hamidou sow]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/**#####################################################################################################
* \ la fonction supprimer permet la suppression des informations d'un étudiant dans le fichier inscription
* \ elle reçoit en paramètre le flux en mode écriture et en mode lecture dans lequel on doit supprimer
* \ VOID pas de valeur de retour
*/
 
 
void SUPPRIMER(ofstream &flux_1,ifstream &flux_2,string &chemin)
{
  ofstream temp("tampon.txt");
  ifstream temp1("tampon.txt");
   info_etud e;
 
   bool test=false;
   string ligne,matri;
   cin.ignore();
   cout<<"DONNER LE MATRCULE DE LETUDIANT ";getline(cin,matri);
   if(flux_2)
   {
      while(getline(flux_2,ligne))
    {
     if(ligne.find(matri)==1)
     {
       test=true;
 
     }
    }
    flux_2.close();
   }else {cout<<"erreure douverture du flux_2"<<endl;}
 
   cin.ignore();
 
    if(test)
     {
       flux_2.open(chemin.c_str());
      while(getline(flux_2,ligne))
      {
        if(ligne.find(matri)==1)
         {
           cout<<"ligne retrouver suppression en cour "<<endl;
           for(int i=0;i<100;i+=10)
           {
             if(i%10==0) cout<<char(16);
 
           }
           cout<<endl;
           continue;
 
         }
         else
         {
           temp<<ligne<<endl;
         }
       }
      }
      else{cout<<"LE NUMERO MATRICULE SAISI N\'EXISTE PAS "<<endl;}
      flux_2.close();
      temp.close();
      if(true)
      {
      ofstream flux(chemin.c_str());
      string copie;
      while(getline(temp1,copie))
      {
        flux<<copie<<endl;
      }
      flux.close();
      temp1.close();
      remove("tampon.txt");
      cout<<endl<<"suppression effectuer avec succee "<<endl;
      }
   }