Differences

This shows you the differences between two versions of the page.

Link to this comparison view

appunti3s:stream [2018/04/25 07:55] (current)
Line 1: Line 1:
 +====== Stream (flusso di dati) ======
 +Si sono già utilizzati gli operatori %%>>​%% e %%<<​%% nella pagine [[appunti3s:​cin_cout]]
 +>> Nel seguente testo i termini input e output sono sempre riferiti al programma, cioè input significa "in ingresso al programma"​. Il soggetto che riceve input è il programma.
 +
 +===== Operatore Extractor >> =====
 +
 +A questo livello di studio, si può comprendere che Extractor è un operatore che si applica su due //​oggetti//:​ un oggetto Istream (stream di input, come std::cin) che rappresenta cioè i caratteri in ingresso al programma (come quelli provenienti dalla tastiera) e un oggetto dove i caratteri sono destinati a finire (variabili del programma). ​
 +<​code>​std::​cin >> varstring;</​code>​
 +{{ :​appunti3s:​extractor.png |}}
 +===== Operatore Insertion << =====
 +
 +Anche questo è un operatore che si applica su due //​oggetti//:​ un oggetto Ostream (stream di output, come std::cout) che rappresenta i caratteri in uscita dal programma (come quelli diretti verso il monitor) e un oggetto da cui i caratteri provengono (variabili del programma).
 +<​code>​std::​cout << "​testo";</​code>​
 +
 +Questi operatori restituiscono a loro volta uno stream
 +<​code>​ ostream&​ operator<<​ ( ostream&,​...)</​code>​
 +quindi possono essere usati ricorsivamente,​ eseguendo l'​espressione come se ci fossero aggiunte le parentesi tonde.
 +<​code>​ (std::cout << "Mario ") << "​Rossi"​ << std::​endl;</​code>​
 +====== fstream ======
 +
 +In modo analogo a std::cout e cin, il programmatore può definire nuovi oggetti stream di output (o di input) e successivamente applicare l'​operatore Insertion (o Extractor) per eseguire operazioni di output (o di input) per il programma.
 +
 +<​code>​
 +std::​ifstream is;  //​dichiarazione oggetto input stream (di input per il programma)
 +is >> varstring; ​  // operazione di lettura con Extractor: è input per il programma!
 +                   // l'​input si arresta al primo spazio bianco....</​code>​
 +<​code>​
 +std::​ofstream os;  //​dichiarazione oggetto output stream (di output per il programma)
 +os << "​testo"; ​    //​operazione di scrittura con Insertion: è output per il programma!</​code>​
 +
 +Questi sono "​oggetti"​ e devono essere utilizzati nell'​ottica della programmazione orientata agli oggetti.
 +Gli oggetti di tipo //​ifstream//​ sono predefiniti per l'​input,​ mentre //​ofstream//​ sono predefiniti per l'​output. Gli oggetti //fstream// possono essere usati indifferentemente per Input e Output.
 +
 +===== File =====
 +Un file contiene una sequenza ​ di numeri memorizzati sulla memoria di massa. ​
 +  * Se ogni Byte rappresenta un carattere (char), il file può essere trattato come un //file di caratteri// (metodo predefinito). ​
 +  * Se rapprensentano altro (es: un float, che occupa diversi Byte) il file deve essere trattato come un //file binario//​.  ​
 +Se non diversamente specificato un file è aperto come file di testo, altrimenti in caso di immagini, file audio, file eseguibili, si devono aprire in formato binario.
 +
 +Un file possiede un nome (di solito con estensione) una data e il formato in cui sono organizzati i dati al suo interno. (vedere problema dei caratteri nei nomi dei file e problema dei {{appunti4s:​formati.pdf}} proprietari)
 +Un file può essere aperto in diversi "​modi":​ in lettura, in scrittura o in entrambi i modi.
 +<file c stream.cpp>​
 +/* questo programma è stato scritto da Fabio
 + ​* ​
 + * fa un esempio di lettura e scrittura su file di testo
 + */
 +#include <​string>​
 +#include <​iostream>​
 +#include <​fstream>​
 +
 +int main()
 +{
 +   ​std::​string nomeFile("​nessuno.txt"​);​
 +
 +   ​std::​cout << "​Inserire il nome del file \n" ;
 +   ​std::​cin >> nomeFile;
 +   
 +         // definisce un oggetto stream aperto in lettura e scrittura (deve esistere).
 +         // se era aperto solo in scrittura poteva anche non esistere ​        
 +   ​std::​fstream flussoFile(nomeFile.c_str(),​std::​ios_base::​in|std::​ios_base::​out);  ​
 +
 + // ma apertura in lettura puo' dare errore se file inesistente.
 + if (!flussoFile) std::cout << "​can'​t open input file"<<​std::​endl;​
 +
 +   ​std::​string parola("​bla"​);​
 +   ​flussoFile << "testo a piacere..."; ​ // operazione di scrittura con Insertion: è output dal programma!
 +   ​flussoFile >> parola; ​  // operazione di lettura con Extractor: è input per il programma! attenzione agli spazi bianchi...
 +
 +   ​return 0;
 +}
 +</​file>​
 +
 +Invece che leggere da una file una parola su una variabile (string) si può leggere anche un numero su una variabile float (o di altro tipo numerico) ​
 +<​code>​
 +   ​double d;
 +   ​flussoFile >> d;  // extractor preleva caratteri dal file e li trasforma in dati dentro d
 +   ​flussoFile << d;  // insertion deposita caratteri dentro il file a partire dai dati dentro d
 +</​code>​
 +===== Stati dei flussi file =====
 +
 +Gli oggetti stream possiedono degli //stati// che possono essere verificati con delle funzioni:
 +<​code>​
 +flussoFile.good();​ // restituisce true se è tutto ok
 +flussoFile.eof(); ​ // restituisce true se la lettura del file ha raggiunto la fine del file.
 +flussoFile.fail();​ // restituisce true se l'​ultima operazione sul file è fallita.
 +flussoFile.bad(); ​ // restituisce true se l'​errore è più grave.
 +</​code>​
 +<​code>​
 +flussoFile.clear(); ​ // pulisce lo stato per riprovare l'​operazione
 +flussoFile.unget(); ​ // restituisce indietro il dato letto
 +flussoFile.exceptions(ios_base::​badbit); ​ // lancia un'​eccezione
 +</​code>​
 +===== Posizionamento =====
 +Un file può essere letto sequenzialmente,​ oppure ci si può spostare su e giù per il file (0.. n-1)
 +<​code>​
 +   ​std::​ifstream flussoFile(nomeFile.c_str());​ //apertura in lettura predefinita
 +   ​flussoFile.seekg(5); ​   // posizione 6 (Seek) per lettura (Get).
 +   ​flussoFile >> varchar; ​ // lettura di un carattere
 +</​code>​
 +<​code>​
 +   ​std::​ofstream flussoFile(nomeFile.c_str());​ //apertura in scrittura predefinita
 +   ​flussoFile.seekp(5); ​   // posizione 6 (Seek) per scrittura (Put).
 +   ​flussoFile << "​z"; ​ // scrittura di un carattere
 +</​code>​
  
  • appunti3s/stream.txt
  • Last modified: 2018/04/25 07:55
  • (external edit)