Biblioteca iostream manipulatori

Administrator Data inscrierii: 07/Dec/2013 Mesaje: 1103

• Cand se utilizeaza aceasta biblioteca, se va include <iostream>. Fisierul iostream contine definitiile claselor care implementeaza obiecte flux si consimt folosirea bufferelor. Este un echivalent al lui <stdio> din ANSI C.

• Sistemul de intrare/iesire este apt de a formata operatiile de intrare/iesire care se refera la:
- precizarea dimensiunii unui camp;
- specificarea bazei unei constante numerice intregi;
- stabilirea preciziei in afisarea datelor in virgula mobila etc.

• Operatiile de intrare / iesire, folosind biblioteca iostream, se vor realiza prin supraincarcarea, in C++, a operatorilor <<si>>. Operatorul <<reprezinta>> se citesc valori din fluxul cin in variabile. Se realizează o convertire automata a sirurilor externe la reprezentarea interna a variabilelor conform tipului lor ( a se compara cu formatarea din scanf( ) din C ).

• Formatarea datelor se poate realiza prin doua cai:
a) acces direct la diversi membri ai clasei ios, adica se pot controla diferiti indicatori pentru format definiti in clasa ios, sau apeland functii membre ale clasei ios;
b) prin functii particulare ce se pot include in expresii de intrare / iesire, numite manipulatori.

• Fiecarui stream i se asociaza un set de indicatori de format, care controleaza modul in care sunt formatate informatiile de catre stream. Ei vor fi prezenti in lantul operatorilor de iesire. In clasa ios, de regula, acestor indicatori li se atribuie cate un identificator si o valoare prin enumerare. In standardul ANSI C++, tipul indicatorilor de compus este fmtflags. In mod uzual, pentru compilatoarele actuale, se foloseste, pentru acesti indicatori, tipul long.

• Indicatorii de format asociati unui stream sunt:
a) indicatori pentru alinierea iesirii:
- right ( prin activarea sa se produce alinierea iesirii la dreapta);
- left ( prin activarea sa se produce alinierea iesirii la stanga);
In mod implicit, alinierea iesirii se face la dreapta.
b) indicator pentru eliminarea spatiilor libere (blanc, tabulator, linie noua)ce preced intrarea unui stream:
- skipws.
c) indicator ce cauzează inserarea de spatii intr-o valoare numerica incepand de la semn sau de
la caracterul bazei:
- internal;
d) indicatori pentru afisarea / schimbarea bazei:
- showbase (prin activarea sa se determina afisarea bazei numarului);
- oct (prin activarea sa se determina afisarea iesirii in octal);
- hex (prin activarea sa se determina afisarea iesirii in hexazecimal);
- dec (prin activarea sa se determina afisarea iesirii in zecimal);
In mod implicit, iesirea se afiseaza in zecimal.
e) indicatori pentru afisarea semnului:
- showpos (prin activarea sa se determina afisarea semnului + inaintea valorilor pozitive);
f) indicatori pentru afisarea iesirii in virgula flotanta:
- showpoint (prin activarea sa se determina afisarea, la iesirea flotanta, a punctului zecimal si a zerourilor finale);
- scientific (prin activarea sa se determina afisarea iesirii in notatie stiintifica);
In notatia stiintifica, afisarea se face cu litere mici: e, x (exponent, baza hexazecimala) etc.
- uppercase (prin activarea sa se determina afisarea iesirii cu litere mari: E,X ).
- fixed (prin activarea sa se determina afisarea iesirii flotante in mod normal, rezervand, in mod implicit sase pozitii pentru fracțiune zecimala).
g) indicator pentru golirea sistemului de intrare / iesire din C++ dupa fiecare operatie de iesire:
- unitbuf;

• Activarea indicatorilor de format se realizeaza cu ajutorul functiei setf( ), care este o functie membra a clasei ios.
long setf(long indicatori);

Aceasta functie activeaza doar indicatorii care corespund parametrilor ei, ceilalti, daca exista, raman nemodificati. Functia returneaza valorile precedente ale indicatorului de format.
Exemplu:
# include <iostream>
void main ( ){
cout.setf (ios::oct);
cout.setf (ios::showbase);
cout<<2000; // precizati afisarea!
};
Acelasi lucru se obtine daca luam:
cout.setf (ios::showbase | ios::oct); // se foloseste operatorul or.

Toti indicatorii de format sunt definiti in interiorul clasei ios. Accesul la valorile lor este permis prin constructia:
ios::id_indicator

• Dezactivarea indicatorilor de format se face cu susținerea functiei unsetf( ), care este tot o functie membra a clasei ios.
long unsetf(long indicatori);

Aceasta functie este utila in stergerea a unul sau mai multi indicatori de format corespunzatori parametrilor ei. Functia returneaza dispoziția anterioara a indicatorilor de format.

Exemplu:
# include<iostream>
void main( ){
cout.setf(ios::hex| ios::oct);
cout<<199; // se va afisa c7
cout.unsetf(ios::hex);
cout<<”\n”<<199; // se va afisa 307
}

• Ca orice functie membra, functia setf( ) se poate supraincarca.
long setf(long ind_1, long ind_2);

Efectul este urmatorul:
- se dezactiveaza indicatorii de format precizati in ind_2;
- sunt afectati doar indicatorii de format precizati in ind_2 in functie de ind_1 (daca ind_1 mai contine si alti indicatori care nu exista in ind_2, acestia nu vor fi modificati).
- functia returneaza starea anterioara a indicatorului de format.
Exemplu:
# include<iostream>
void mai( ){
cout.setf(ios::showbase| ios::oct);
cout<<1000; // se afiseaza 01750
cout.setf(ios::dec,ios::oct | ios::dec);
cout<<”\n”<<1000; // se activeaza dec si se afiseaza 1000
};

• Se poate face referire la oricare din campurile oct, dec, hex, prin ios::basefield.
• Se poate referi oricare din campurile left, right, internal, prin ios::adjustfield.
• Se poate referi oricare din campurile scientific, fixed, prin ios::floatfield.
Exemplu:
# include<iostream>
void mai( ){
cout.setf(ios::showbase| ios::oct);
cout<<1000; // se afiseaza 01750
cout.setf(ios::dec,ios::basefield);
cout<<”\n”<<1000; // se afiseaza 1000
};

• Examinarea starii curente a indicatorilor de format, fara a modifica valoarea lor, se poate face cu ajutorul functiei flags( ).
long flags( );
Exemplu:
# include<iostream>
void showflags( );
void main( ){
showflags( ); // se arata starea implicta a indicatorilor
cout.setf(ios::left|ios::right|ios::showpoint);
showflags( );
}
void showflags( ){
long f1,f2;
int k;
char tab[5][8]={
"left",
"right",
"dec",
"oct",
"hex"};
f1=cout.flags(); // starea indicatorilor de format
for(f2=1,k=0;f2<=0x10;f2=f2<<1,k++)
if(f2&f1)cout<<tab[k]<<" este activat\n";
else cout<<tab[k]<<" este dezactivat\n";
cout<<"\n";
}

Iesirea programului:

left este activat
right este dezactivat
dec este dezactivat
oct este dezactivat
hex este dezactivat
left este activat
right este activat
dec este activat
oct este dezactivat
hex este dezactivat

• Activarea tuturor indicatorilor de format asociati unui stream se realizeaza prin:
long flags(long lf);

Sunt afectati toti indicatorii de format asociati streamului respectiv, deoarece in variabila ce retine acesti indicatori se copiaza structura de biti din lf.
Functia returneaza starea anterioara.

• In clasa ios exista trei functii membre care activeaza parametri pentru format:
int width(int dc );
Prin aceasta functie se specifica o mărime minima (dc) a campului in care se va afisa o iesire, solicitata de unele implementari inainte de iesire. Ea returneaza măsură anterioara a lui. Odata specificata aceasta dimensiune minima a campului de afisare, valorile, care urmeaza a fi afisate, nu vor fi trunchiate, campul extinzandu-se pana la mărimea necesara.
In mod implicit, se respecta dimensiunea data de numarul caracterelor componente ale acelei iesiri.

• Cand se solicita o anumita precizie inaintea unei iesiri ce reprezinta o valoare flotanta, se poate utiliza functia:
int precision (int pr);
Precizia este indicata de pr, iar functia returneaza valoarea precedenta. In mod implicit, precizia este de 6 cifre.

• In mod implicit, un camp la iesire este completat, pana la dimensiunea precizata, cu spatii. Daca se doreste o umplere cu alt gen de caractere, se va utiliza functia:
char fill (char ch);

Caracterul de umplere este ch, iar functia returneaza caracterul anterior.
Exemplu:
# include<iostream>
void main(){
cout<<3.14562894<<”\n”;// afiseaza 3.14562 (afisare implicita)
cout.precision(5);
cout.width(10);
cout<<3.14562894<<"\n"; //afiseaza 3.1456 (se rotunjeste, daca este cazul, cf.preciziei)
cout.fill('#');
cout.width(10);
cout<<"Sesiunea de examene!"<<"\n";// sirul nu se trunchiaza! Campul se extinde.
cout.width(10);
cout<<"Sesiunea"<<"\n";
cout.width(10);// afiseaza ##Sesiunea (aliniere implicita la dr.)
cout.setf(ios::left);
cout<<3.14562894;// afiseaza 3.1456#### (se umple pana la 10 caractere cu aliniere la
//stanga)
}

• O alta posibilitate, prin care se pot modifica parametrii de formatare ai unui stream, consta in folosirea unor functii speciale, care se includ in expresii de intrare / iesire, numite manipulatori.
Un avantaj in utilizarea manipulatorilor, spre deosebire de indicatorii de formatare, consta intr-o anume compactificare in scriere, in sensul ca este permisa o inlantuire a mai multor operatori << cu formate diferite.
• Se cunoaste faptul, ca întrebuințarea bufferelor de intrare / iesire presupune folosirea unor blocuri de memorie ca zone de depozitare temporara a octetilor cititi dintr-un flux sau scrisi intr-un flux. Manipulatorii actioneaza asupra unor astfel de buffere in sensul, ca ei pot forta golirea completa a unui buffer, pot obliga afisarea continutului afluxului cout inainte de umplerea bufferului etc.
• Manipulatorii sunt declarati in iostream.h. Pentru a utiliza acei manipulatori, care folosesc parametri, se va include fisierul iomanip.h.
• Sa punem in evidenta manipulatorii disponibili in iostream.

Exemplu:

# include<iostream>
# include<iomanip>
void main( ){
int k=900;
cout<<"Utilizarea manipulatorilor"<<"\n";
cout<<k<<"\n";
cout<<"Scrie numarul in octal"<<"\n";
cout<<oct<<k<<endl;
cout<<"Scrie numarul in hexazecimal"<<"\n";
cout<<hex<<k<<endl;
// Se seteaza dimensiunea campului si se umple cu '*'cf. alinierii
cout<<setfill('*');
cout<<setw(5)<<oct<<k<<endl;
cout<<setw(5)<<hex<<k<<endl;
cout<<setiosflags(ios::left);
cout<<setw(5)<<oct<<k<<endl;
cout<<setw(5)<<hex<<k<<endl;
}

• Cand intr-un program se intalneste, de mai numeroase ori, aceeasi secventa de operatii de intrare/iesire, se pot defini functii de manipulare proprii.

a) Crearea manipulatorilor fara parametri:
//functie de manipulare a iesirii fara parametri
ostream&id_manip(ostream&str){
//........
return str;
}

- id_manip este identificatorul manipulatorului;
- se returneaza o referinta la un stream de tipul ostream;
- cand manipulatorul este introdus intr-o operatie de iesire nu are parametru;
Exemplu:
# include<iostream>
# include<iomanip>
//Utilizarea unui manipulator de iesire
ostream&scrie_octal(ostream&str)
{
str.setf(ios::showbase);
str.setf(ios::oct);
return str;
}
void main( ){
int k=900;
cout<<k<<"...."<<scrie_octal<<setw<<k;
}

// functii de manipulare a intrarii, fara parametri

istream&id_manip(istream&str)
{
//.....................
return str;
}
Exemplu:
# include<iostream>
# include<string>
// crearea unui manipulator de intrare
istream&anunt(istream&str)
{
cout<<'\t';
cout<<"Incepe anul universitar!\n";
cout<<"Precizati data calendaristica!\n";
return str;
}
void main ( ){
char dat[15];
cin>>dat;
while(strcmp(dat,"1.oct.1999")){
cout<<"Anunt incorect\n\n";
cin>>anunt>>dat;
};
cout<<"Data corecta\n";
}

• Exista probabilitatea de a crea si manipulatori cu parametri. Acestia insa sunt mai greu de intuit si in acelasi timp, metoda de creare a lor, depinde de compilator. De aceea, astfel de manipulatori se utilizeaza cu clase generice (template).

• Este important ca manipulatorul sa returneze un stream pentru a putea fi întrebuințat intr-o secventa de operatii de intrare/iesire.