Programarea calculatoarelor și limbaje de programare – notițe de curs/ Curs 5

Programarea calculatoarelor și limbaje de programare – Curs 5

IV. LIMBAJELE C și C++

IV.7. Paradigma programării orientate spre obiecte……………….…….1
IV 8. Spații de nume în C++……………………………………………..3
IV.9. Citire/scriere în C++…………………………………...…….…….4

IV.7. Paradigma programării orientate spre obiecte

Limbajul C++ păstrează elementele limbajului C, la care adaugă un setul de

completări care îl face mai riguros, și construcțiile necesare pentru aplicarea
principiilor programării orientate pe obiect.
Să ne reamintim că modelul programării structurate procedurale constă în
descompunerea programului în subprograme (proceduri/funcții). Datele sunt separate
de funcțiile/procedurile care le manipulează. Odată cu creșterea dimensiunii și
complexității programelor s-a trecut la organizarea datelor în module –
funcțiile/procedurile, împreună cu datele pe care le manevrează sunt organizate ca un
modul. Programarea modulară este tot programare procedurală, cu proceduri/funcții și
date grupate în module și ascunse altor module. În cazul programării orientată spre
obiecte, programele sunt organizate ca niște colecții de obiecte cooperante, fiecare
dintre ele reprezentând o instanță a unei clase, iar clasele sunt membre ale unei ierarhii
de clase, corelate între ele prin relații de moștenire. Astfel noțiunile de bază sunt
următoarele:
• Obiectul este elementul de bază și reprezintă abstractizarea unei entități a
lumii reale. Fiecare obiect are asociate niște funcții și o valoare numită stare.
Fiecare obiect aparține unei clase.
• Clasa definește atât structura datelor asociate unor obiecte, cât și
comportamentul acestor obiecte (operațiile care se pot aplica acestor
obiecte).
• Metoda este o funcție ce poate fi aplicată unui obiect dintr-o clasă dată.
Mulțimea metodelor asociate unei clase dau interfața cu utilizatorul pentru

1
 Mădălina Roxana. Buneci

obiectele acelei clase. Aceasta înseamnă că utilizatorii unei clase văd doar
o listă de metode împreună cu semnăturile (anteturile) lor (tipul
parametrilor de intrare și tipul rezultatului), ceea ce poartă denumire de
încapsulare. C++ se distinge de limbajele orientate spre obiect pure prin
faptul că permite controlul accesului atât la datele membre (încapsulare
selectivă), cât și la funcțiile membre ale unei clase (prin folosirea
specificatorilor de control ai accesului: public, private, protected).
• Ierarhia claselor presupune construirea unor structuri arborescente în care
arcele corespund subordonării unei subclase față de o clasă dată. Pentru
subclase se aplică proprietatea de ereditate. Ereditatea este proprietatea prin
care orice subclasă păstrează toate caracteristicile clasei căreia îi este
subordonată. În particular, un obiect A al unei subclase date poate fi utilizat
ca parametru actual în apelul unei funcții ori de câte ori a fost menționat ca
parametru formal un obiect B dintr-o clasa căreia îi este subordonată
subclasa dată. Corpul unei metode dintr-o anumită clasă poate fi redefinit
în oricare din subclasele sale, dar păstrând același nume.
• Polimorfismul constă în esență în posibilitatea asocierii mai multor
implementări aceleași metode, iar sistemul de calcul trebuie să fie în măsură
să stabilească implementarea corespunzătoare metodei apelate. Această
decizie se poate lua fie la compilare (early sau static binding), fie în
momentul execuției (late sau dynamic binding).
Pe scurt obiectul este o variabilă care conține date (atribute) și are funcții
asociate acestuia (comportament asociat). O clasă este un tip de date definit de
programator care este utilizat pentru a declara obiecte. O clasă conține descrieri ale
datelor și funcțiilor care vor fi asociate obiectelor. Declarația unui obiect arată ca o
declarație a unei variabile:
nume_clasa nume_obiect;
Dacă o este un obiect al unei clase și tip_rezultat f(tip1, tip2 ,…) este o metodă
a clasei atunci pentru aplicarea metodei f asupra obiectului o se folosește operatorul
punct
o.f(p1, p2,…)

2
 Programarea calculatoarelor și limbaje de programare – notițe de curs/ Curs 5

unde p1, p2, … sunt parametrii actuali.

IV.8. Spații de nume în C++

Spațiul de nume (namespace) este o caracteristică adăugată în C ++ și care nu

este prezentă în C. Un program folosește diverși identificatori (nume) asociați
variabilelor, funcțiilor, etc. Odată cu creșterea dimensiunii și complexității programelor
și cu dezvoltarea acestora de către echipe de dezvoltatori, a apărut problema
posibilității de a defini sau folosi aceiași identificatori în diverse module de către
diverși membri ai echipelor de dezvoltare. Pentru a izola spațiile de definiție și acces
la identificatorii introduși de fiecare programator, pentru a elimina astfel conflictul
generat de utilizare încrucișată a identificatorilor, s-au introdus spațiile de nume.
Acestea oferă mecanisme de protejare/ascundere a identificatorilor definiți de fiecare
programator, sau definiți în biblioteci dezvoltate de alții și utilizați în programul
propriu. Astfel în C++ identificatorii sunt grupați în spații de nume – namespaces. Dacă
nu plasăm codul într-un anumit spațiu de nume, atunci codul se află într-un spațiu de
nume cunoscut sub numele de spațiu de nume global (global name space). Declarația
unui spațiu de nume se face în felul următor:
namespace nume_spatiu {
declarațiile identificatorilor ce aparțin spațiului
}
- Declarațiile spațiilor de nume se fac doar la nivel global.
- Declarațiile spațiilor de nume pot fi imbricate.
- Nu este necesar să punem punct și virgulă după acolada de închidere a
definiției spațiului de nume.
- Putem împărți definiția spațiului de nume pe mai multe unități (O unitate
este un fișier, împreună cu toate fișierele care sunt incluse prin directiva
#include în fișier-sau echivalent ceea ce rezultă în urma preprocesării).
Folosirea identificatorilor definiți în spațiul de nume din afara spațiului de nume
se face prin operatorul de rezoluție :: sub forma
nume_spatiu::identificator

3
 Mădălina Roxana. Buneci

Se pot folosi directive using pentru a face vizibili toți identificatorii dintr-un spațiu de
nume sub forma:
using namespace nume_spatiu;
sau declarații using pentru a face vizibili anumiți identificatori:
using nume_spatiu::identificator;
Domeniul de aplicare al unei directive using este de la locul unde apare până la
sfârșitul blocului sau fișierului (dacă nu a fost plasată într-un bloc).
Se pot defini spații de nume fără nume. În acest caz membrii lor se pot utiliza
de la punctul de declarație până la sfârșitul unității.
Există un spațiu de nume predefinit, cu numele std, din care fac parte toți
identificatorii din biblioteca C++ standard.

IV.9. Citire/scriere în C++

Facilitățile de intrare/ieșire în C++ sunt implementate prin intermediul

bibliotecii standard (nu prin instrucțiuni din limbaj). Operațiile de intrare/ieșire în C++
se realizează prin intermediul fluxurilor (streamuri). Un flux este o entitate în care un
program poate insera sau din care poate extrage. Fluxurile sunt o sursă/destinație de
caractere (bytes), iar aceste caractere sunt furnizate/acceptate secvențial.
Fluxurile de intrare/ieșire standard sunt:
cin – stream standard de intrare
cout – stream standard de ieșire
cerr – stream standard de ieșire pentru erori
clog – stream standard de ieșire pentru înregistrarea evenimentelor
Fluxul standard de intrare este cin (de obicei asociat tastaturii), în timp ce fluxul
standard de ieșire (de obicei asociat ecranului) este cout. Obiectele cin și cout sunt
declarate în iostream (deci este necesară directiva preprocesor #include <iostream>).
Biblioteca iostream folosește simbolul << pentru ieșiri și >> pentru intrări din,
respectiv în fluxul de date. Identificatorii cout și cin aparțin spațiul de nume std și
pentru a-i putea folosi trebuie folosit fie operatorul de rezoluție
std::cout;

4
 Programarea calculatoarelor și limbaje de programare – notițe de curs/ Curs 5

std::cin;
fie declarații using
using std::cout;
using std::cin;
fie directiva
using namespace std;
Sintaxa generala de apel pentru cout este de forma:
std::cout << expr1[<<expr2]……[<<exprn1;
unde:
• expri (i=1..n) pot fi literali, constante, variabile, apeluri de funcții sau expresii
valide în limbajul C++, inclusiv manipulatori de format (setw, setiosflags,
setprecision, resetiosflags, setbase, etc);
• << este un simbol atașat fluxului cout, numit și operator de ieșire

Fluxul cout se poate utiliza pentru afișarea unei singure expresii sau mai multor
expresii.
Fluxul de intrare cin, redirectează intrările, citirile, către fișierul standard de
intrare, stdin, asociat, de cele mai multe ori, tastaturii.
Sintaxa generală de apel este de forma:
cin >> v1[>>v2]……[>>vn];
unde:
• vi (i=1..n) sunt variabile de tipuri valide în limbajului C++ sau manipulatori;
• >> un simbol atașat fluxului cin, numit si operator de intrare
Variabilele vi pot fi de tip int, float, double, char sau tipuri derivate ale acestora.
Fluxul cin se poate utiliza pentru citirea mai multor variabile, de pe aceeași linie.
Fluxul cin utilizează caracterele albe (spațiu, tab sau linie nouă) pentru a delimita
valorile variabilelor care urmează să fie citite.
În C++ formatarea ieșirilor și a intrărilor se poate face utilizând
- manipulatori de format
- funcții membre
- flag-uri

5
 Mădălina Roxana. Buneci

Manipulatori
Manipulatori sunt funcții speciale proiectate să funcționeze cu operatorii de ieșire
(<<) și intrare (>>) împreună cu unul dintre obiectele asociate fluxurilor de
intrare/ieșire.
Este suficient să utilizăm #include <iostream> pentru folosirea unui manipulator
fără parametri. Pentru folosirea unui manipulator cu parametri trebuie să adăugăm în
secțiunea directivelor preprocesor #include <iomanip>.
Manipulatori definiți în <ios>:
boolalpha
noboolalpha
comută între reprezentarea textuală și numerică a constantelor booleene (false/0, true/1)
showbase
noshowbase
controlează dacă se afișează sau nu un prefix care să indice baza pentru numere
showpoint
noshowpoint
controlează dacă punctul zecimal este afișat întotdeauna pentru un număr în virgulă
mobilă
showpos
noshowpos
controlează dacă semnul + este utilizat cu un număr nenegativ
skipws
noskipws
controlează dacă caracterele albe (whitespaces) sunt ignorate la intrare
uppercase
nouppercase
controlează dacă majusculele sunt utilizate la ieșire în anumite formate

6
 Programarea calculatoarelor și limbaje de programare – notițe de curs/ Curs 5

unitbuf
nounitbuf
controlează dacă buferul de ieșire este golit după fiecare operațiune.
Din motive de eficiență, cea mai mare parte a ieșirii nu este trimisă direct la dispozitivul
de ieșire în momentul în care un program folosește o instrucțiune de ieșire (prin
intermediul cout). Mai degrabă este colectat într-un buffer de ieșire din memoria
sistemului. Periodic, conținutul colectat al buferului este golit către dispozitivul de
ieșire într-un bloc mare. Acest lucru este mult mai rapid decât trimiterea ieșirii câte un
caracter odată. Această golire are loc automat atunci când conținutul buferului devine
prea mare. Buferul de ieșire este, de asemenea, golit înainte de executarea unei
instrucțiuni de intrare. Acest lucru se datorează faptului că rezultatul poate fi un prompt
și un mesaj ar trebui să apară pe ecran în întregime înainte ca orice intrare să fie
acceptată. Buferul de ieșire este golit și atunci când fluxul este închis la sfârșitul
programului.
internal
left
right
setează plasarea caracterelor de umplere
dec
hex
oct
modifică baza utilizată pentru operațiile de intrare/ieșire cu întregi/
fixed
scientific
hexfloat (începând cu C++11)
defaultfloat (începând cu C++11)
modifică formatul pentru operațiile de intrare/ieșire cu numere în virgulă mobilă
Dacă nu utilizăm manipulatori (sau echivalentul lor) sau dacă folosim defaultfloat,
formatul implicit pentru fiecare număr în virgulă mobilă depinde de valoarea acestuia.

7
 Mădălina Roxana. Buneci

• Niciun punct zecimal: 2.0000 imprimă ca 2

• Fără zerouri finale: 2.5000 de tipăriri ca 2.5
• Notație științifică pentru numere mari/mici: 1234567890.0 se tipărește
ca 1.23457e + 09
Manipulatori definiți în <istream>:
ws
consumă caracterele albe (acesta este un manipulator numai pentru intrare)
Manipulatori definiți în <ostream> (aceștia sunt manipulatori numai pentru
ieșire):
ends
inserează un caracter nul '\0' în secvența de ieșire
flush
golește fluxul de ieșire (forțează toate ca toate rezultatele să fie scrise pe ecran sau în
fișier; fără flush rezultatele ar fi aceleași, dar este posibil să nu apară în timp real).
endl
adaugă '\n' (trecerea la rând nou) și golește fluxul de ieșire

Manipulatori cu parametri (definiți în <iomanip>)

setw (n): Este folosit pentru a seta lățimea câmpului la ieșire.
setfill (c): Este folosit pentru a completa cu caracterul „c” câmpul la ieșire dacă
lățimea lui este mai mică decât cea setată.
setprecision (n): Setează n ca nouă valoare pentru precizia valorilor în virgulă
mobilă.
setbase(b): Este folosit pentru a seta baza b pentru valorile numerice.
setiosflags(flag): Este folosit pentru a seta flag-uri de format
resetiosflags(flag): Este folosit pentru a reseta flag-uri de format
Ex.
. std::setiosflags(std::ios::fixed), pentru afișarea in virgula fixă
. std::setiosflags(std::ios::scientific), pentru format științific

8
 Programarea calculatoarelor și limbaje de programare – notițe de curs/ Curs 5

Funcții membre
• setf() – funcția setează flags-urile care trebuie activate
• unsetf() -- funcția resetează flags-urile
• precision() -- setează precizia pentru valorile în virgulă mobilă la un anumit număr
de cifre semnificative după virgulă zecimală
• width() - precizează numărul minim de caractere (coloane) folosite pentru afișarea
datelor specificate în următoare ieșire.
Indicatoarele de aliniere stânga și dreapta se vor aplica atunci când această funcție este
utilizată pentru a specifica lățimile câmpurilor. Spațiul suplimentar din câmp va fi
completat cu un caracter de umplere, care este setat implicit la un spațiu.
Ex.
std::cin.unsetf(std::ios::dec);
std:: cout.width(3)

Manipulatori vs flags-uri

fixed ios::fixed

scientific ios::scientific

ios::showpoint
showpoint

showpos ios::showpos

Right ios::right
Left ios::left

Operații de citire /scriere cu fișiere text

Datele pot fi citite și dintr-un fişier în loc să fie introduse de la tastatură, și pot
fi scrise într-un fişier în locul afişării rezultatelor direct pe ecran.
Pentru a folosi fluxurie asociate fișierelor, în program trebuie declarată
directiva preprocesor:

9
 Mădălina Roxana. Buneci

#include <fstream>
Operatiile specifice lucrului cu fișiere text sunt:
1) Declararea fluxului asociat unui fișier și deschiderea acestuia:
a. pentru scriere
b. pentru citire
c. pentru citire/scriere
2) Scrierea sau citirea;
3) Închiderea fișierului
Deschiderea unui fişier pentru citire se realizează cu:
ifstream fin(“nume fisier de intrare”);
iar citirea datelor din fişier prin
fin >> variabila;
Deschiderea unui fișier pentru scriere se realizează cu:
ofstream fout(“nume fisier de iesire”);
iar scrierea în fișier prin
fout << expresie;
Închiderea fişierelor se face cu
fin.close();
respectiv,
fout.close();

Exemplu
#include <iostream>
#include <fstream>
using namespace std;
int main () {
ifstream fin("input.txt");
ofstream fout("output.txt");
int a, b;
fin >> hex >> a >> b;
fout << dec << a << " + " << b << " = " << a + b << endl;

10
 Programarea calculatoarelor și limbaje de programare – notițe de curs/ Curs 5

fout << showbase << hex << a << " + " << b << " = " << a + b << endl;
fout << oct << a << " + " << b << " = " << a + b << endl;
return 0;
}
Dacă fișierul input.txt conține
b1 a1
După execuția programul fișierul output.txt va conține
177 + 161 = 338
0xb1 + 0xa1 = 0x152
0261 + 0241 = 0522
Dacă nu se folosește directiva using namespace std, trebuie folosit operatorul
de rezoluție pentru a face vizibili identificatorii din spașiul de nume std:

#include <iostream>
#include <fstream>
int main () {
std::ifstream fin("input.txt");
std::ofstream fout("output.txt");
int a, b;
fin >> std::hex >> a >> b;
fout << std::dec << a << " + " << b << " = " << a + b << std::endl;
fout << std::showbase << std::hex << a << " + " << b << " = "
<< a + b << std::endl;
fout << std::oct << a << " + " << b << " = " << a + b << std::endl;
return 0;
}

11