[C++] File (binari)

[ing82]

Tenendo sempre presente che l'utente finale sono io stesso, direi che allora posso affrontare il problema in questo modo:

All'apertura del file, verifico che sia stato effettivamente aperto, con istruzioni simili a queste:

  std::fstream fs;//faro' ifstream o ofstream in base alle necessita'
  fs.open ("test.txt");//ci posso aggiungere la modalita' di apertura
  if (fs.is_open())
  {
    //quello che devo fare
    fs.close();
  }
  else
  {
    std::cout << "Error opening file";
  }

Per la scrittura quindi potrei fare

  fs.write(/*scrittura 1*/);
  fs.write(/*scrittura 2*/);
  //elenco di tutto quello che devo scrivere
  if(fs.good())
  {
    std::cout<<"Scrittura avvenuta con successo";
  }
  else
  {
    std::cout<<"Lettura fallita";
  }

Per la lettura, una cosa simile,

  fs.read(/*lettura1*/);
  fs.read(/*lettura2*/);
  fs.read(/*letturan*/);
  if(fs.good())
  {
    std::cout<<"Lettura avvenuta con successo";
  }
  else
  {
    std::cout<<"Lettura fallita";
    //decido se ripristinare i valori di default nel caso di un oggetto, ripristinare i valori precedenti o non so che altro, in base al caso specifico
  }

Cosi' facendo sono nella condizione di sapere almeno se tutto e' andato bene o no.
In questo modo comunque non dovrei avere blocchi durante l'esecuzione, approfondiro' poi con maggior calma tutto il resto.

Ultima cosa: quanto scritto in precedenza, come mia interpretazione, e' corretto?

Mi autoquoto:

Credo allora di aver interpretato male la seguente frase, che viene
riportata identica sia per il metodo write che per il metodo read:



"Basic guarantee: if an exception is thrown, the object is in a valid state.

It throws an exception of member type failure if the resulting error state flag is not goodbit and member exceptions was set to throw for that state.

Any exception thrown by an internal operation is caught and handled by the function, setting badbit. If badbit was set on the last call to exceptions, the function rethrows the caught exception."



Io l'avevo interpretata come "se qualcosa va male, l'oggetto stream resta sempre in uno stato valido, nel senso che posso comunque sapere cosa e' successo mediante i flag interni, da interrogare mediante gli appositi metodi." (non e' una traduzione letterale, ma quanto ho interpretato io).

[ing82]

Tenendo sempre presente che l'utente finale sono io stesso, direi che allora posso affrontare il problema in questo modo:

Mi rimangio la parola: guardando meglio l'esempio postato da Shodan al link http://en.cppreference.com/w/cpp/io/...ios/exceptions la faccenda di semplifica di molto, mi ero 'spaventato' per niente, ma cosi' pare molto piu comodo.

Grazie

[ing82]

Stavo provando il seguente pezzo di codice:

#include <iostream>     // std::cerr
#include <fstream>      // std::ifstream
#include <string>

int main () {
  std::ifstream file;
  file.exceptions ( std::ifstream::failbit | std::ifstream::badbit);
  try
  {
    file.open ("test.txt");
    std::string c;
    while (!file.eof())
    {
      getline(file, c);
      std::cout<<c<<std::endl;
    }
  }
  catch (const std::ifstream::failure& e)
  {
    std::cout<<"\nSto gestendo l'eccezione\n";
    std::cerr << e.what() ;
  }
  file.close();

  return 0;
}

Col seguente file di testo (dopo l'ultima riga sono andato a capo, ho dato invio, quindi c'e' una riga vuota:

pippo
pluto
paperino
123456
ultima riga

Mi aspettavo che funzionasse tutto senza eccezioni, invece ottengo il seguente output:

pippo
pluto
paperino
123456
ultima riga

Sto gestendo l'eccezione
basic_ios::clear

Da quanto ho letto dovrebbe essere causato dal fatto che la lettura dell'ultima riga mediante il getline, trovando niente, setta sia failbit che eofbit, da qui il messaggio di errore.
Infatti, se tolgo l'ultima riga vuota, non ottengo messaggi di eccezioni.

E' corretto, o manca altro?