OPERAŢII DE INTRARE/IEŞIREatitech.unitbv.ro/ungureanu/docs/PCLP_I_-_curs_-_prezentari/AIA-C12-CPP.pdf(limbaj de programare C++) ... Sursa şi/sau destinaţia datelor pot fi asociate

Cursul nr. 12

OPERAŢII DE INTRARE/IEŞIRE

(limbaj de programare C++)


Sistemul I/O din C++ are la bază conceptul de stream (flux) care reprezintă dispozitive logice folosite în transferul de informaţie între o sursă de date şi destinaţia sa.

Sursa şi/sau destinaţia datelor pot fi asociate cu dispozitive fizice sau, pentru formatare în memorie, unor şiruri de caractere.

Toate streamurile se comportă la fel, chiar dacă echipamentele fizice la care sunt conectate pot să difere substanţial.

Aceleaşi funcţii pot fi folosite pentru scrierea în fişiere, pe ecran sau la imprimantă.


Operaţiile de I/O se realizează cu ajutorul a două ierarhii de clase declarate în fişierele iostream.h (operaţii cu consola) şi fstream.h (operaţii cu fişiere).

Ierarhiile de clase folosite în operaţiile I/O

OPERAŢII DE INTRARE/IEŞIRE. FIŞIERE.

La lansarea în execuţie a unui program C++ se deschid patru streamuri predefinite, dispozitive logice de intrare/ieşire standard

Stream Semnificaţie Echipament implicit

Dispozitiv echivalent în C

cin intrare standard tastatură stdincout ieşire standard ecran stdoutcerr ieşire standard pentru eroare ecran stderrclog ieşire standard pentru eroare cu

memorie tamponecran -

OPERAŢII DE INTRARE/IEŞIRE PENTRU CONSOLĂ

Operaţii de intrare/ieşire cu consola

Pentru operaţiile I/O se folosesc operatorii << şi >> care au fost supradefiniţi pentru operaţii de ieşire şi respectiv de intrare cu streamuri. Utilizarea dispozitivelor şi operatorilor de intrare/ieşire C++ impune includerea fişierului antet iostream.h.

Sintaxa folosită este următoarea:

cin >> var; /* citeşte var de la cin */cout << var; /* scrie var la cout */

Se pot face operaţii de intrare, respectiv ieşire, multiple, cu sintaxa:

cin >> var1 >> var2 ... >> varN;cout << var1 << var2 ... << varN;


Supradefinirea operatorilor <<, respective >>, este făcută pentru toate tipurile predefinite de date.

Astfel, tipurile datelor transferate către cout pot fi: toate tipurile aritmetice; şiruri de caractere; pointeri de orice tip în afară de char.

Tipurile datelor citite de la cin pot fi: toate tipurile aritmetice; şiruri de caractere.

pentru afişarea adresei unui şir este necesara o conversie explicită la pointer de alt tip, de exemplu (void *).

Valorile adreselor se afişează în hexazecimal.


Formatarea datelor folosind membrii ios

Formatul datelor pentru operaţiile de intrare-ieşire este controlat de variabilele, cum ar fi:

long int x_flags; // cuvântul de formatint x_width; // dimensiunea câmpului de formatint x_fill; // caracterul de completare a câmpului de

//format (implicit este spaţiu)int x_precision; // precizia pentru valori în virgulă mobilă

// (număr de zecimale)

OPERAŢII DE INTRARE/IEŞIRE PENTRU CONSOLĂ Cuvântul de format conţine un număr de indicatori care sunt

biţi individuali cărora li se asociază un nume şi o valoare prin enumerarea:

enum{skipws = 0x0001, // sare peste spaţii (la intrare)left = 0x0002, // aliniere stânga (la ieşire)Right = 0x0004, // aliniere dreapta (la ieşire)Internal = 0x0008, // completare internă (la ieşire)dec = 0x0010, // conversie zecimalăoct = 0x0020, // conversie octalăhex = 0x0040, // conversie hexazecimalăshowbase = 0x0080, // afişare bază (la ieşire)showpoint = 0x0100, // afişare punct zecimal (la ieşire)uppercase = 0x0200, // afişare hexazecimală cu majuscule

// (la ieşire)showpos = 0x0400, // afişare numere pozitive precedate de

// caracterul + (la ieşire)scientific = 0x0800, // numere reale în format ştiinţific fixed = 0x1000, // numere reale în format cu punct fixunibuf = 0x2000, // goleşte zona tampon după fiecare scrierestdio = 0x4000 // goleşte zona tampon după scriere în stdout

// sau stderr};

OPERAŢII DE INTRARE/IEŞIRE PENTRU CONSOLĂ Activarea indicatorilor de format se face folosind funcţia setf()

care este membră a clasei ios:

long setf(long indicator);

Exemplu:

#include <iostream.h>

void main(){

cout.setf(ios::showpos);cout.setf(ios::uppercase);cout.setf(ios::scientific);cout << 123.456;

}

Rezultatul afişării este:

+ 1.234560E+002


Pentru dezactivarea indicatorilor de format se foloseşte funcţia:

long unsetf(long indicator);

Exemplu:

cout.unsetf(ios::uppercase);

OPERAŢII DE INTRARE/IEŞIRE PENTRU CONSOLĂ Alţi parametri destinaţi formatării sunt: mărimea câmpului,

precizia şi caracterul de umplere. Aceştia pot fi activaţi cu funcţiile membre width(), precision(), fill().

#include <iostream.h>void main(){ cout << 123 << endl ; // afişarea se face pe dimensiune implicita

cout.width(10); // se modifica câmpul la dimensiunea 10cout << 123 << endl ;cout.width(10); // se modifica câmpul la dimensiunea 10cout.fill('*'); // se stabileşte caracter de umplere '*'cout << 123 << endl ;cout.width(10); // se modifica câmpul la dimensiunea 10cout.precision(2); // se specifica afişarea cu precizie 2cout.setf(ios::fixed); // fixed este activatcout << 123.456 << endl;

}Rezultatul execuţiei este:

123123

*******123****123.45


Utilizarea manipulatorilor fără parametru pentru formatareaI/O

dec - activează bitul dec (la intrare/ieşire)hex - activează bitul hex (la intrare/ieşire)oct - activează bitul oct (la intrare/ieşire)ws - activează bitul skipws, deci omite spaţiile libere de la început (la intrare)endl - inserează caracterul ‘\n’ şi goleşte tamponul (la ieşire)ends - inserează caracterul ‘\0’ (la ieşire)flush - goleşte tamponul (la ieşire)

Exemplu:#include <iostream.h>

void main() {cout << "un numar in zecimal: " << dec << 15 << endl;cout << "in octal: " << oct << 15 << endl;cout << "in hex: " << hex << 15 << endl;cout << "un numar in virgula mobila: " << 3.14159 << endl;cout << “afisarea unui caracter: " << char(75) << endl;

}

un numar in zecimal: 15in octal: 17in hex: fun numar in virgula mobila: 3.14159afisarea unui caracter: K


Utilizarea manipulatorilor cu parametru pentru formatarea I/O

setbase(int n) - stabileşte baza n=8, 10 sau 16;resetiosflags(long) - înscrie 0 pentru biţii specificaţi prin parametru;setiosflags(long) - înscrie 1 pentru biţii specificaţi prin parametru;setfill(int) - stabileşte caracterul de umplere;setprecision(int) - stabileşte precizia pentru numere în virgulă mobilă;setw(int) - stabileşte dimensiune câmpului pentru operaţia

următoare.Exemplu:#include <iostream.h>#include <iomanip.h>

void main(){ cout << 123 << endl ;

cout << hex << setiosflags(ios::showbase) << 123 << endl ;cout << oct << 123 << endl ;cout << 1234.56 <<endl;cout << setprecision(1)<< setw(10)<< setfill('*')<< setiosflags(ios::fixed);cout << 1234.56 << endl;

}

1230x7b01731234.56****1234.6


Operaţii de intrare/ieşire cu fişiere

Lucrul cu un fişier presupune deschiderea fişierului, prelucrarea fişierului şi închiderea lui.

Deschiderea fişierului se face prin asocierea lui cu un stream, adică se asociază unui obiect de tip fstream, ofstream sau ifstream.

Un stream poate avea asignat un singur fişier la un moment dat.

Clasele care reprezintă fluxuri asociate fişierelor sunt definite în biblioteca fstream:

ifstream: flux unidirecţional care permite citirea de date dintr-un fişier ofstream: flux unidirecţional care permite scrierea de date dintr-un fişier fstream: flux bidirecţional care permite citiri şi scrieri în/din fişier


Deschiderea şi asignarea unui fişier se pot efectua în momentul declarării streamului, sau se pot efectua ulterior, cu metoda open() a streamului.

Sintaxele pentru constructorii acestor două clase sunt:

fstream Variabila(char *NumeFisier, ios::Mod);ofstream Variabila(char *NumeFisier, ios::Mod);ifstream Variabila(char *NumeFisier);

unde NumeFisier reprezintă numele fişierului, inclusiv calea sa, care va fi asociat cu obiectul care se creează, iar Mod reprezintă modul de deschidere a fişierului.

Varianta folosind constructorul:fstream fisier("nume_fisier", optiuni);

Varianta folosind funcţia open:fstream fisier;fisier.open("nume_fisier", optiuni);


Moduri de deschidere a fişierelor

Mod deschidere Utilizare

ios::app Deschide un fişier de ieşire pentru completare (appending). Dacăfisierul nu există, este creat. Datele sunt scrise la sfârşitul fişierului.

ios::ate Deschide un fişier existent (pentru citire sau/şi scriere) şipoziţionează prompterul la sfârşitul fişierului, dar scrierea se poateface acolo unde este poziţionat prompterul.

ios::in Deschide un fişier pentru citire. Poate fi utilizat şi cu un ofstream,pentru a preveni trunchierea unui fişier deja existent.

ios::out Deschide un fişier pentru scriere. Dacă fişierul nu există, este creat.Dacă fişierul există, iar ios::out este folosit fără modurile ios::app,ios::ate sau ios::in, atunci este implicat modul ios::trunc (fişieruleste golit şi prompterul este poziţionat la start).

ios::nocreate Deschide un fişier numai dacă acesta deja există pe disc, altfeloperaţia eşuează.

ios::noreplace Deschide un fişier (creează unul nou) numai dacă acesta nu existadeja, altfel operaţia eşuează.

ios::trunc Deschide un fişier nou şi îl şterge pe cel vechi (dacă acesta dejaexistă)

ios::binary Deschide un fişier în modul binar (modul text este implicit)

OPERAŢII DE INTRARE/IEŞIRE. FIŞIERE. Opţiunile se pot combina folosind operatorul „|”. În cazul în care opţiunile lipsesc, valorile implicite sunt:

Exemple de utilizare:

// creaza obiectul fisier pentru citire/scriere si deschide fisierul// "test.txt" folosindconstructorul si optiunile implicite

fstream fisier("test.txt");// deschide fisierul pentru citire in mod binar

ifstream fcitire;fcitire.open("date.dat", ios::in | ios::binary);

// deschide fisierul "studenti.txt" in mod text pentru// scriere la sfarsitul fisierului

ofstream fscriere("studenti.txt", ios::out | ios::app);

Clasa Opţiuniifstream ios::inofstream ios::outfstream ios::in | ios::out


De exemplu, fişierul date.txt poate fi deschis cu instrucţiunea:

ofstream fis_out("date.txt", ios::app);

sau

ofstream fis_out;fis_out.open("date.txt", ios::app);

Dacă operaţia de deschidere a unui fişier eşuează, membrul ios::failbit va fi setat.Pentru a închide aceste fişiere, trebuie apelată funcţia membră close(). De exemplu:

fis_out.close();

OPERAŢII DE INTRARE/IEŞIRE. FIŞIERE.#include<fstream.h>

void main(void){ const int dim=1024;

char buf[dim];

ofstream fis_out;ifstream fis_in;

fis_out.open("date.txt", ios::app);// deschiderea fişierului în mod appendif ( ! fis_out ) // testarea reuşitei operaţiei de deschidere

cout<<"Eroare la deschiderea fisierului \"date.txt\""<<endl;else{ fis_out<<"EXEMPLU DE SCRIERE IN FISIER! \n"; // scriere în fişier

fis_out.close(); // închiderea fişierului}

fis_in.open("date.txt"); // deschiderea fişierului pentru operaţii de citirewhile (!fis_in.eof()) // testare sfârşit de fişier{ fis_in.getline(buf, dim); // citirea unei linii din fişier

cout<<buf<<endl; // afişarea textului citit}fis_in.close(); // închiderea fişieruluireturn;

}


După deschiderea unui fişier, trebuie să testăm succesul operaţiei printr-o instrucţiune de forma:

if (fis_out.fail() ) cout<<"Eroare la deschiderea fisierului \"date.txt\""<<endl;

sau, pentru că operatorul ! a fost supraîncărcat pentru a da ca rezultat valoarea returnată de metoda fail() a stream-ului testat:

if ( ! fis_out ) cout<<"Eroare la deschiderea fisierului \"date.txt\""<<endl;

Verificarea faptului că un fişier este deschis se poate face folosind funcţia membru is_open().

if(!fis_out.is_open())cout<<"Eroare la deschiderea fisierului \"date.txt\""<<endl;

OPERAŢII DE INTRARE/IEŞIRE. FIŞIERE.Pozitionarea în fişier se poate determina si modifica prin pointeri (indicatoride poziţie).In cazul stream-urilor de intrare, prompterul este numit “get pointer”, şi poate fi aflată cu funcţia membru tellg(). Pointerul poate fi poziţionat cu seekg(). În cazul stream-urilor de ieşire a prompterul este numit “put pointer” şi funcţiile membre corespunzătoare sunt tellp() şi seekp().

istream & seekg(long);istream & seekg(long, seek_dir);ostream & seekp(long);ostream & seekp(long, seek_dir);long istream::tellg(); // aflarea valorii pointerului “get”,long ostream::tellp(); // aflarea valorii pointerului “put”,

Ambele metode (seekg si seekp) primesc doi parametri:•un întreg reprezentând deplasarea pointerului în raport cu baza(referinţa) precizată de al doilea parametru;•o constantă întreagă care precizează baza. Valorile constantei suntdefinite în clasa ios:

class ios{ //. . .public:

enum seek_dir{beg=0, deplasare faţă de începutul fişierului (implicit)cur=1, deplasare faţă de poziţia curentăend=2 deplasare faţă de sfârşitul fişierului

};};


ofstream fis_out;

// deschiderea fisierului în mod appendfis_out.open("date.txt", ios::app);// testarea reusitei operatiei de deschidereif(!fis_out.is_open())

cout<<"Eroare la deschiderea fisierului\"date.txt\" "<<endl;else{

// citire pointercout<<"\nPointer p = "<< fis_out.tellp()<<endl;// scriere în fisierfis_out<<"EXEMPLU DE SCRIERE IN FISIER! \n";// citire pointercout<<"\nPointer p = "<< fis_out.tellp()<<endl;// închiderea fisieruluifis_out.close();

}


ifstream fis_in;

// deschiderea fisierului pentru operatii de citirefis_in.open("date.txt");

while (!fis_in.eof()) // testare sfârsit de fisier{ // citirea unei linii din fisier

fis_in.getline(buf, dim);

// citire pointercout<<"\nPointer g = "<< fis_in.tellg()<<endl;

// afisarea textului cititcout<<buf<<endl;}


// resetarea flag-urilor de starefis_in.clear();

// repozitionare la inceputul fisieruluifis_in.seekg(0,fis_in.beg);


// citirea unei linii din fisierfis_in.getline(buf, dim);


// afisarea textului cititcout<<buf<<endl;


Pentru operaţiile de scriere/citire din fişiere se pot folosi atât funcţiile de inserţie/extracţie (<<, >>), cât şi metode ale claselor. Astfel, se poate scrie în fişier folosind operatorul << :

fis_out<<"EXEMPLU DE SCRIERE IN FISIER! \n"; // scriere în fişier

Pentru citirea, respective scrierea unui caracter, se pot folosi metodele get() (funcţie supradefinită), respectiv put() cu prototipurile:

istream& get(char&);istream& get(char*buf, int numar, char delim=’\n’);int get();ostream&put(char);

De exemplu, dacă se doreşte afişarea conţinutului unui fişier, se poate scrie:

ifstream fis_in.open("date.txt");char ch;while(fis_in.get(ch))

cout<< ch;fis_in.close();


Pentru citirea unei linii se poate folosi functia getline()

istream& getline(char*buf, int numar, char delim=’\n’);

De exemplu:fis_in.getline(buf, dim); // citirea unei linii din fişier

Funcţia citeşte numărul de caractere specificat, sau citirea se încheie la întâlnirea delimitatorului specificat.

La citirea dintr-un fişier, parte din conţinut poate fi ignorat folosind metoda ignore() cu prototipul:

istream&ignore(int num=1, int delim=EOF);

Spre exemplu:ifstream fis_in.open("date.txt");char buf[dim];fis_in.ignore(10); // se ignora 10 caracterefis_in.getline(buf, dim);fis_in.close();


Modul binar de lucru cu fisiere presupune utilizarea funcţiilor read() şi write(), care, spre deosebire de operatorii de inserţie/extracţie, sunt indiferente la eventuala semnificaţie de caractere de control a octeţilor manipulaţi. Funcţiile au prototipurile:

istream& read(unsigned char*buf, int numar);

ostream& write(const unsigned char*buf, int numar);

Parametrii precizează adresa de memorie de la care se citeşte, respectiv la care se scrie şi numărul octeţilor citiţi, respectiv scrişi.

ifstream fis_in.open("date.txt");char buf[dim];fis_in.read(buf, 10);cout<<buf;fis_in.close();

OPERAŢII DE INTRARE/IEŞIRE. FIŞIERE.#include <fstream.h>

int main(){ char fileName[80];

char buffer[255]; // pentru introducerea textului de la tatatura

cout << "File name: ";cin >> fileName;

ofstream fout(fileName); // deschidere pentru scrierefout << "Acest text se scrie direct in fisier...\n";cout << "Introdu un text pentru a-l inregistra in fisier: ";cin.ignore(1,'\n'); // se preia caracterul '\n' ramas in buffer

// dupa introducerea numelui fisieruluicin.getline(buffer,255); // citirea textului de la tastaturafout << buffer << "\n"; // si inregistrarea in fisierfout.close(); // se inchide fisierul

ifstream fin(fileName); // redeschiderea fisierului pentru citirecout << "\n***Acesta este continutul fisierului***\n";char ch;while (fin.get(ch)) // citirea fisierului caracter cu caracter

cout << ch; // afisarea continutului pe ecrancout << "\n***Sfarsitul continutului fisierului.***\n";fin.close(); // inchiderea fisieruluireturn 0;

}

Documents

OPERAŢII DE INTRARE/IEŞIREatitech.unitbv.ro/ungureanu/docs/PCLP_I_-_curs_-_prezentari/AIA-C12-CPP.pdf(limbaj de programare C++) ... Sursa şi/sau destinaţia datelor pot fi asociate