GESTION DES FICHIERS EN C++

La gestion des fichiers signifie lire et écrire dans des fichiers (comme .txt, .csv, etc.) à l'aide des classes fournies par la bibliothèque standard C++.

Les programmes s'exécutent dans la RAM, ce qui signifie que les données n'existent que pendant l'exécution du programme. Lorsqu'un programme se termine, toutes les données de la RAM sont automatiquement perdues.
La gestion des fichiers permet de stocker les données dans la mémoire secondaire (comme le disque dur ou le SSD) afin qu'elles puissent être conservées de manière permanente et puissent être enregistrées et consultées même après la fin du programme.
Pour les opérations sur les fichiers, C++ fournit des classes de flux de fichiers dans le en-tête tel que ofstream ifstream fstream.

Ouvrir un fichier

Avant de lire ou d'écrire dans un fichier, nous devons d'abord l'ouvrir. L'ouverture d'un fichier charge ce fichier dans la RAM. En C++, nous ouvrons un fichier en créant un flux à l'aide du fstream classe qui représente le flux de fichier, c’est-à-dire le flux pour l’entrée et la sortie du fichier.

C++

    fstream     str  (  'filename.ext'       mode  );

où

str : Nom donné au flux
nom de fichier: Nom du fichier
mode : Représente la manière dont nous allons interagir avec le fichier.

Modes d'ouverture de fichiers

Le mode d'ouverture du fichier indique que le fichier est ouvert pour la lecture, l'écriture ou l'ajout. Vous trouverez ci-dessous la liste de tous les modes de fichiers en C++ :

Mode	Description
ios ::dans	Fichier ouvert en lecture. Si le fichier n'existe pas, l'opération d'ouverture échoue.
ios :: sortie	Fichier ouvert en écriture : le tampon de flux interne prend en charge les opérations de sortie.
ios :: binaire	Les opérations sont effectuées en mode binaire plutôt qu'en mode texte.
ios :: mangé	La position de sortie commence à la fin du fichier.
ios :: application	Toutes les opérations de sortie ont lieu à la fin du fichier en s'ajoutant à son contenu existant.
ios :: tronc	Tout contenu qui existait dans le fichier avant son ouverture est supprimé.

Par exemple si nous voulons ouvrir le fichier en lecture, nous utilisons le mode d'ouverture suivant :

C++

    fstream     filein  (  'file.txt'       ios  ::  in  );

De même, si nous voulons ouvrir le fichier en écriture, nous utilisons ce qui suit :

C++

    fstream     fileout  (  'file.txt'       ios  ::  out  );

Ces modes peuvent également être combinés à l'aide de l'opérateur OR (|). Par exemple, vous pouvez ouvrir le flux de fichiers en mode lecture et écriture, comme indiqué :

C++

    fstream     str  (  'file.txt'       ios  ::  in     |     ios  ::  out  );

Si le fichier ouvert en écriture n'existe pas, un nouveau fichier est créé. Mais si le fichier ouvert en mode lecture n'existe pas alors aucun nouveau fichier n'est créé et une exception est levée

Autres flux de fichiers

fstream n'est pas le seul flux de fichiers fourni par C++. Il existe deux filières plus spécialisées :

ifstream : représente le flux de fichier d'entrée. Cela équivaut à ouvrir fstream dans ios ::dans mode.
de flux : représente le flux de fichier de sortie. Cela équivaut à ouvrir fstream dans ios :: sortie mode.

Les modes ci-dessus sont les modes par défaut pour ces flux. Ces modes ne peuvent pas être modifiés mais peuvent être associés à d’autres modes. Maintenant, pour la saisie, nous pouvons également utiliser ifstream comme indiqué :

C++

    ifstream     filein  (  'file.txt'  );

De même pour la sortie :

C++

    ofstream     fileout  (  'file.txt'  );

Écrire des données dans un fichier

Une fois le fichier ouvert en mode écriture en utilisant soit fstream ou de flux nous pouvons effectuer l'opération d'écriture de la même manière qu'avec cout en utilisant < < operator.

C++

    #include          using     namespace     std  ;   int     main  ()     {      // Open a file      ofstream     file  (  'GFG.txt'  );          // Write the string to the file      file      < <     'Welcome to GeeksforGeeks.'  ;      return     0  ;   }

GFG.texte

Lire les données d'un fichier

Une fois le fichier ouvert en mode lecture en utilisant fstream ou ifstream, nous pouvons effectuer l'opération d'écriture de la même manière qu'avec cin en utilisant >> opérateur.

C++

    #include          using     namespace     std  ;   int     main  ()   {      // Open a file in read mode      ifstream     file  (  'GFG.txt'  );      string     s  ;      // Read string from the file      file     >>     s  ;      cout      < <     'Read String: '      < <     s  ;      return     0  ;   }

Sortir

 Read String: Welcome   Cela a le même problème que cin. L'entrée n'est prise que jusqu'au premier caractère d'espacement. Pour éviter cela, nous pouvons utiliser le     obtenir la ligne()    Fonctionne comme indiqué :  
 C++      #include          using     namespace     std  ;   int     main  ()   {      // Open a file in read mode      ifstream     file  (  'GFG.txt'  );      string     s  ;      // Read string from the file      getline  (  file       s  );      cout      < <     'Read String: '      < <     s  ;      return     0  ;   }   
     
    Sortir    
  Read String: Welcome to GeeksforGeeks.   Fermeture du fichier  
  Fermer le fichier signifie fermer le flux associé et libérer les ressources que nous utilisons. Il est important de fermer le fichier une fois que vous avez terminé, en particulier dans les programmes à exécution longue, pour éviter les fuites de mémoire, les pertes de données, etc.  
  En C++, les fichiers sont fermés à l'aide du     fermer()    fonction membre présente dans tous les flux de fichiers.  
 C++      #include          using     namespace     std  ;   int     main  ()   {      // Open a file in read mode      ifstream     file  (  'GFG.txt'  );      string     s  ;      // Read string from the file      getline  (  file       s  );      cout      < <     'Read String: '      < <     s  ;      // Close the file      file  .  close  ();      return     0  ;   }   
     
    Sortir    
  Read String: Welcome to GeeksforGeeks.   Erreurs dans la gestion des fichiers  
  De nombreux types d'erreurs peuvent survenir lors de la gestion des fichiers, par exemple un fichier introuvable, un disque plein, etc. Nos programmes doivent s'attendre à des erreurs courantes et doivent être capables de les gérer correctement. Voici quelques erreurs courantes pouvant survenir lors de la gestion des fichiers :  
  Échec d'ouverture de fichier  
  Il peut y avoir des cas dans lesquels le fichier n'est pas ouvert pour diverses raisons telles qu'il n'existe pas ou que le programme n'est pas autorisé à l'ouvrir, etc. Dans ce cas, nous pouvons utiliser le     est_ouvert()    fonction membre des classes de flux de fichiers pour vérifier si le fichier est ouvert avec succès ou non.  
 C++      #include          using     namespace     std  ;   int     main  ()     {      fstream     file  (  'nonexistent_file.txt'       ios  ::  in  );      // Check if the file is opened      if     (  !  file  .  is_open  ())     {      cerr      < <     'Error: Unable to open file!'      < <     endl  ;      return     1  ;      }      file  .  close  ();      return     0  ;   }   
     
    Sortir    
  Error: Unable to open file!   Échec de lecture/écriture de données  
  Une autre erreur courante est l'échec de la lecture ou de l'écriture des données pour des raisons telles qu'un mode incorrect, etc. Dans ce cas, nous pouvons valider les opérations après chaque tentative de lecture/écriture. Par exemple, la lecture à l'aide de getline() peut être validée comme indiqué :  
 C++      #include          using     namespace     std  ;   int     main  ()     {      fstream     file  (  'GFG.txt'       ios  ::  out  );      if     (  !  file  .  is_open  ())     {      cerr      < <     'Error: Unable to open file!'      < <     endl  ;      return     1  ;      }      string     line  ;          // Checking if getline() read successfully or not      if     (  !  getline  (  file       line  ))      cerr      < <     'Error: Failed to read data'      < <     endl  ;      file  .  close  ();      return     0  ;   }   
     
    Sortir    
  Error: Failed to read data   Erreur de fin de fichier (EOF)  
  Essayer de lire au-delà de la fin du fichier peut provoquer une erreur EOF. Cela peut arriver lorsque vous ne vérifiez pas la fin du fichier avant de le lire. Nous pouvons vérifier EOF en utilisant     eof()    fonction membre.  
 C++      #include          using     namespace     std  ;   int     main  ()   {      ifstream     file  (  'GFG.txt'  );      if     (  !  file  .  is_open  ())      {      cerr      < <     'Error: Unable to open file!'      < <     endl  ;      return     1  ;      }      string     line  ;      while     (  getline  (  file       line  ))      cout      < <     line      < <     endl  ;      // Check for eof      if     (  file  .  eof  ())      cout      < <     'Reached end of file.'      < <     endl  ;      else      cerr      < <     'Error: File reading failed!'      < <     endl  ;      file  .  close  ();      return     0  ;   }   
     
    Sortir    
  Reached end of file.   Notez que nous avons également validé l'opération de lecture avant de vérifier EOF comme     obtenir la ligne()    je reviendrai seulement     nullptr    même si la lecture échoue pour une raison quelconque.  
  Gestion des fichiers binaires  
  En C++, nous pouvons également gérer     fichiers binaires    qui stockent les données au format brut. Pour lire et écrire des données binaires, il faut utiliser le     ios :: binaire    drapeau lors de la création/ouverture d’un fichier binaire.  
  Écrire dans un fichier binaire  
  Pour écrire des données dans un fichier binaire, nous devons d'abord ouvrir ou créer le fichier dans     ios :: binaire    mode.  
 C++      #include         #include         #include          using     namespace     std  ;   int     main  ()   {      string     str     =     'Welcome to GeeksForGeeks'  ;      // Open a binary file for writing      ofstream     file  (  'fileBin.bin'       ios  ::  binary  );      // Check if the file is open      if     (  !  file  )      {      cerr      < <     'Error opening the file for writing.'  ;      return     1  ;      }      // Write the length of the string (size) to file first      size_t     strLength     =     str  .  length  ();      file  .  write  (  reinterpret_cast   <  const     char     *>  (  &  strLength  )     sizeof  (  strLength  ));      // Write the string to the binary file      file  .  write  (  str  .  c_str  ()     strLength  );      // Close the file      file  .  close  ();      return     0  ;   }   
     
    Sortir    
  Fichier binaire  Lecture à partir d'un fichier binaire  
  Tout comme nous ouvrons un fichier en mode binaire pour écrire des données pour lire les données d'un fichier binaire, nous devons ouvrir le fichier en mode lecture en utilisant     ios ::dans    .  
     Syntaxe:    
 C++      fstream     fileInstance  (  'fileName.bin'       ios  ::  in  |     ios  ::  binary  );   
  C++      #include         #include         #include          using     namespace     std  ;   int     main  ()   {      string     str  ;      // Open the binary file for reading      fstream     file  (  'fileBin.bin'       ios  ::  in     |     ios  ::  binary  );      // Check if the file is open      if     (  !  file  )      {      cerr      < <     'Error opening the file for reading.'  ;      return     1  ;      }      // Read the length of the string (size) from the file      size_t     strLength  ;      file  .  read  (  reinterpret_cast   <  char     *>  (  &  strLength  )     sizeof  (  strLength  ));      // Allocate memory for the string and read the data      char     *  buffer     =     new     char  [  strLength     +     1  ];     // +1 for the null-terminator      file  .  read  (  buffer       strLength  );      // Null-terminate the string      buffer  [  strLength  ]     =     ''  ;      // Convert the buffer to a string      str     =     buffer  ;      // Print file data      cout      < <     'File Data: '      < <     str  ;      delete  []     buffer  ;      file  .  close  ();      return     0  ;   }   
     
    Sortir    
  File Data: Welcome to GeeksForGeeks   Autres opérations sur les fichiers  
  Nous pouvons également effectuer plus d'opérations pour manipuler un fichier à partir de notre programme C++. Certaines des opérations courantes sur les fichiers sont :  
         Programme C++ pour supprimer un fichier      
       Ajouter une chaîne dans un fichier existant      
       Copier un fichier dans un autre fichier      
 
 
         Créer un quiz