C++ păstrează sistemul de intrare/ieșire din C, dar adaugă unul propriu, construit pe
principiile programării orientate pe obiecte: mai sigur, mai flexibil și extensibil la tipuri definite
de utilizator. Această ultimă lucrare face și trecerea de la structuri la clase.
1Obiectivele lucrării
Utilizarea streamurilor cin, cout, cerr și clog
Formatarea ieșirii cu manipulatori
Lucrul cu fișiere prin ifstream și ofstream
Definirea unei clase cu date membre și funcții membre
Scrierea constructorilor și a destructorului
Aplicarea principiului încapsulării
2Ierarhia de clase I/O
Operațiile de intrare/ieșire se realizează cu ajutorul a două ierarhii de clase, declarate în
fișierele iostream.h și fstream.h:
Fig. 1 - Ierarhiile de clase folosite în operațiile de intrare/ieșire
3Streamurile predefinite
Stream
Semnificație
Echipament implicit
Echivalent în C
cin
intrare standard
tastatură
stdin
cout
ieșire standard
ecran
stdout
cerr
ieșire standard pentru erori
ecran
stderr
clog
ieșire pentru erori, cu memorie tampon
ecran
-
Operatorii de flux<< este operatorul de inserție (scriere),
>> cel de extracție (citire). Ambii sunt operatori supraîncărcați, ceea ce
permite înlănțuirea: cout << a << " " << b << endl;
Avantajul față de printfTipul datelor este dedus automat de compilator.
Nu există riscul de a folosi un specificator greșit, iar operatorii pot fi extinși pentru clasele
proprii, astfel încât cout << obiect să funcționeze natural.
4Manipulatori de format
Manipulator
Efect
Antet necesar
endl
linie nouă + golirea tamponului
iostream
setw(n)
lățime minimă de n caractere
iomanip
setprecision(n)
numărul de cifre semnificative
iomanip
fixed
notație zecimală fixă
iostream
scientific
notație științifică
iostream
left / right
alinierea în câmp
iostream
setfill(c)
caracterul de umplere
iomanip
hex / oct / dec
baza de numerație
iostream
boolalpha
afișează true/false în loc de 1/0
iostream
Diferență importantăsetw acționează doar asupra următoarei
valori afișate, apoi se resetează. Ceilalți manipulatori (fixed, setprecision,
hex) rămân activi până la o nouă schimbare.
5Fișiere în C++
Clasă
Rol
Echivalent C
ifstream
citire din fișier
fopen(..., "r")
ofstream
scriere în fișier
fopen(..., "w")
fstream
citire și scriere
fopen(..., "r+")
Închiderea automatăLa ieșirea din domeniul de vizibilitate, destructorul
obiectului închide singur fișierul. Spre deosebire de C, uitarea unui fclose nu mai
este posibilă - este primul beneficiu concret al abordării orientate pe obiecte.
6Clase și obiecte
O clasă extinde noțiunea de structură: pe lângă date, conține și funcțiile care operează asupra lor.
Un obiect este o instanță concretă a unei clase.
structura unei clase
class NumeClasa {
private: // implicit pentru class
tip date_membre; // accesibile doar din interiorul clasei
public:
NumeClasa(); // constructor implicit
NumeClasa(parametri); // constructor cu parametri
~NumeClasa(); // destructor
tip functie_membra(...); // interfata publica
};
Specificator
Acces din interiorul clasei
Din exterior
Din clase derivate
private
da
nu
nu
protected
da
nu
da
public
da
da
da
class vs. struct în C++Singura diferență este accesul implicit:
private pentru class, public pentru struct.
În rest, o structură din C++ poate avea funcții membre, constructori și destructor.
Constructori și destructor
Element
Când se apelează
Caracteristici
Constructor
la crearea obiectului
are numele clasei, nu returnează nimic, poate fi supraîncărcat
Constructor de copiere
la inițializarea dintr-un alt obiect
NumeClasa(const NumeClasa &alt)
Destructor
la distrugerea obiectului
~NumeClasa(), unic, fără parametri
7Simulator: ciclul de viață al unui obiect
Urmăriți momentele exacte în care se apelează constructorul și destructorul,
inclusiv pentru obiectele create într-un bloc interior.
Constructor și destructor - ordinea apelurilor
Ordinea distrugeriiObiectele se distrug în ordinea inversă creării.
Acest mecanism, numit RAII, garantează eliberarea resurselor (memorie, fișiere, conexiuni) chiar și
atunci când funcția se termină pe o cale neașteptată.
8Încapsularea
Datele membre se declară private, iar accesul se face exclusiv prin funcții publice.
Avantajul nu este ascunderea în sine, ci controlul: orice modificare poate fi validată.
de ce contează
class Temperatura {
private:
double celsius;
public:
// fara incapsulare, oricine ar putea scrie t.celsius = -500;
bool setCelsius(double v) {
if (v < -273.15) return false; // validare: zero absolut
celsius = v;
return true;
}
double getCelsius() const { return celsius; }
double getFahrenheit() const { return celsius * 9.0 / 5.0 + 32.0; }
};
Funcții constMarcarea unei funcții membre cu const garantează
că aceasta nu modifică starea obiectului. Compilatorul verifică promisiunea și semnalează orice
încălcare - o formă simplă și eficientă de documentare executabilă.
9Cod sursă
formatare.cpp - manipulatori
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
double pi = 3.14159265358979;
cout << "Implicit: " << pi << endl;
cout << "fixed, 4 zec: " << fixed << setprecision(4) << pi << endl;
cout << "scientific: " << scientific << pi << endl;
cout << fixed << setprecision(2);
// tabel aliniat
cout << "\n" << left << setw(14) << "Produs"
<< right << setw(8) << "Buc"
<< setw(10) << "Pret" << endl;
cout << setfill('-') << setw(32) << "" << setfill(' ') << endl;
cout << left << setw(14) << "Rezistor"
<< right << setw(8) << 120 << setw(10) << 0.15 << endl;
cout << left << setw(14) << "Condensator"
<< right << setw(8) << 45 << setw(10) << 0.80 << endl;
// baze de numeratie
int v = 255;
cout << "\n" << dec << v << " = " << hex << v
<< " (hex) = " << oct << v << " (oct)" << dec << endl;
cout << boolalpha << "\n3 > 5 este " << (3 > 5) << endl;
return 0;
}
clasa_student.cpp - clasă completă
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;
class Student {
private:
string nume;
int varsta;
double medie;
public:
// constructor implicit
Student() : nume("necunoscut"), varsta(0), medie(0.0) {
cout << " [constructor implicit]" << endl;
}
// constructor cu parametri, folosind lista de initializare
Student(string n, int v, double m) : nume(n), varsta(v), medie(m) {
cout << " [constructor pentru " << nume << "]" << endl;
}
// constructor de copiere
Student(const Student &alt)
: nume(alt.nume), varsta(alt.varsta), medie(alt.medie) {
cout << " [copiere pentru " << nume << "]" << endl;
}
~Student() {
cout << " [destructor pentru " << nume << "]" << endl;
}
// functii de acces, cu validare
bool setMedie(double m) {
if (m < 1.0 || m > 10.0) return false;
medie = m;
return true;
}
string getNume() const { return nume; }
double getMedie() const { return medie; }
bool promovat() const { return medie >= 5.0; }
void afiseaza() const {
cout << left << setw(18) << nume
<< right << setw(4) << varsta << " ani"
<< setw(8) << fixed << setprecision(2) << medie
<< " " << (promovat() ? "promovat" : "restanta") << endl;
}
};
int main()
{
cout << "Creare obiecte:" << endl;
Student s1("Popescu Ion", 20, 9.15);
Student s2("Ionescu Maria", 21, 4.30);
Student s3 = s1; // apeleaza constructorul de copiere
cout << "\nLista:" << endl;
s1.afiseaza();
s2.afiseaza();
s3.afiseaza();
cout << "\nIncercare de setare a mediei la 15: ";
cout << (s2.setMedie(15.0) ? "acceptat" : "RESPINS de validare") << endl;
cout << "\nDistrugere (ordine inversa):" << endl;
return 0;
}
fisiere.cpp - I/O cu fișiere în C++
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main()
{
// scriere
{
ofstream fout("date_cpp.txt");
if (!fout) { cerr << "Nu pot scrie!" << endl; return 1; }
fout << "Popescu Ion 20 9.15" << endl;
fout << "Ionescu Maria 21 8.70" << endl;
} // fisierul se inchide AUTOMAT aici, prin destructor
// citire
ifstream fin("date_cpp.txt");
if (!fin) { cerr << "Nu pot citi!" << endl; return 1; }
string nume, prenume;
int varsta;
double medie;
cout << "Continutul fisierului:" << endl;
while (fin >> nume >> prenume >> varsta >> medie) {
cout << " " << nume << " " << prenume
<< ", " << varsta << " ani, media " << medie << endl;
}
fin.close();
// citire linie cu linie
ifstream f2("date_cpp.txt");
string linie;
int nr = 0;
cout << "\nLinie cu linie:" << endl;
while (getline(f2, linie)) {
cout << " " << ++nr << ": " << linie << endl;
}
return 0;
}
10Atelier de cod
Casetele acceptă și C++: cout, string, clase cu constructori și destructori. Urmăriți în ieșire momentul exact în care se apelează fiecare.
Ciclul de viață al unui obiect
#include <iostream>
#include <string>
using namespace std;
class Contor {
private:
string nume;
int valoare;
public:
Contor(string n) : nume(n), valoare(0) {
cout << " [se creeaza " << nume << "]" << endl;
}
~Contor() {
cout << " [se distruge " << nume << ", ajuns la " << valoare << "]" << endl;
}
void creste() { valoare++; }
int citeste() const { return valoare; }
};
int main()
{
cout << "Intram in main:" << endl;
Contor a("a");
{
cout << "Intram intr-un bloc interior:" << endl;
Contor b("b");
b.creste(); b.creste();
cout << " b are valoarea " << b.citeste() << endl;
}
a.creste();
cout << "a are valoarea " << a.citeste() << endl;
cout << "Iesim din main:" << endl;
return 0;
}
De încercatObservați că b este distrus la acolada care închide blocul interior, nu la sfârșitul lui main. Durata de viață a unui obiect este legată de domeniul în care a fost declarat.
Aici scrieți voi codul. Butonul ✓ Verifică rulează programul pe mai multe seturi de date și vă arată imediat unde diferă rezultatul. La final trimiteți traseul ales, iar profesorul îl notează automat.
Fiecare exercițiu are programul deja început, iar comentariile vă spun ce mai trebuie adăugat. Scrieți codul, apăsați ✓ Verifică și citiți ce spune fiecare test picat. Dacă v-ați blocat, deschideți câte un indiciu. Puteți afișa și mesaje pentru utilizator (de tipul Introduceti n:), testul se uită la ce afișați la final.
P1
Tabel aliniat cu setw
Citiți n și apoi n perechi nume nota (nume dintr-un cuvânt, notă întreagă). Afișați fiecare pereche pe un rând: numele aliniat la stânga pe 12 caractere, apoi nota aliniată la dreapta pe 4 caractere.
Aici contează și spațiile: ieșirea se compară caracter cu caracter (doar spațiile de la capăt de rând se ignoră).
intrare2
Ana 10
Constantin 7
ieșireAna 10
Constantin 7
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
int main()
{
int n, nota;
string nume;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> nume >> nota;
/* setw(12) stabilește lățimea DOAR pentru următoarea valoare afișată.
left / right aliniază; rămân active până le schimbați.
cout << left << setw(12) << nume << right << setw(4) << nota << endl; */
}
return 0;
}
P2
Clasa Dreptunghi
Completați metodele clasei Dreptunghi: arie(), perimetru() și patrat(). Programul citește laturile și afișează aria și perimetrul cu două zecimale, apoi true sau false.
intrare4 2.5
ieșire10.00 13.00
false
#include <iostream>
#include <iomanip>
using namespace std;
class Dreptunghi {
private:
double L, l;
public:
Dreptunghi(double a, double b) : L(a), l(b) {}
/* Adăugați trei metode publice:
double arie() const -> L * l
double perimetru() const -> 2 * (L + l)
bool patrat() const -> true dacă laturile sunt egale */
};
int main()
{
double a, b;
cin >> a >> b;
Dreptunghi d(a, b);
cout << fixed << setprecision(2) << d.arie() << " " << d.perimetru() << endl;
cout << boolalpha << d.patrat() << endl;
return 0;
}
P3
Clasa Punct, cu constructor implicit
Completați constructorul clasei Punct, cu valori implicite (0, 0), și metoda distanta(const Punct &q). Programul citește un punct și afișează distanța lui până la origine și până la punctul (1, 1), cu două zecimale.
intrare3 4
ieșire5.00 3.61
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
class Punct {
double x, y;
public:
/* 1. Constructor cu parametri impliciți:
Punct(double a = 0, double b = 0) : x(a), y(b) {}
2. double distanta(const Punct &q) const
-> sqrt((x - q.x)^2 + (y - q.y)^2) */
};
int main()
{
double a, b;
cin >> a >> b;
Punct p(a, b), o, u(1, 1);
cout << fixed << setprecision(2) << p.distanta(o) << " " << p.distanta(u) << endl;
return 0;
}
P4
Constructori și destructori
Completați constructorul și destructorul clasei Obiect ca să afișeze creat <nume> și distrus <nume>. main citește trei nume și creează obiectele în blocuri diferite - urmăriți ordinea în care apar mesajele.
intrarea b c
ieșirecreat a
creat b
distrus b
creat c
distrus c
distrus a
#include <iostream>
#include <string>
using namespace std;
class Obiect {
string nume;
public:
Obiect(string n) : nume(n) {
/* afișați "creat " urmat de nume */
}
~Obiect() {
/* afișați "distrus " urmat de nume */
}
};
int main()
{
string x, y, z;
cin >> x >> y >> z;
Obiect a(x);
{
Obiect b(y);
}
Obiect c(z);
return 0;
}
P5
Setter cu validare
Clasa Temperatura păstrează o temperatură în grade Celsius. Completați metoda setCelsius, care acceptă valoarea doar dacă nu este sub zero absolut (-273.15) și întoarce true/false. Programul citește mai multe valori și afișează pentru fiecare ok sau respins, apoi temperatura finală cu două zecimale.
intrare3
25 -300 -10
ieșireok
respins
ok
-10.00
#include <iostream>
#include <iomanip>
using namespace std;
class Temperatura {
double c;
public:
Temperatura() : c(0) {}
bool setCelsius(double v) {
/* Dacă v < -273.15, nu schimbați nimic și întoarceți false.
Altfel c = v și întoarceți true. */
return false;
}
double getCelsius() const { return c; }
};
int main()
{
Temperatura t;
int n;
double v;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v;
cout << (t.setCelsius(v) ? "ok" : "respins") << endl;
}
cout << fixed << setprecision(2) << t.getCelsius() << endl;
return 0;
}
Problemele pornesc de la un main gol. Formatul ieșirii trebuie respectat exact (spațiile și rândurile noi nu contează, dacă enunțul nu spune altfel), deci nu afișați mesaje pentru utilizator. Testele vizibile acoperă doar cazurile simple; la notare se rulează și teste ascunse, alese să prindă cazurile limită.
A1
Clasa Fractie
Scrieți o clasă Fractie al cărei constructor aduce fracția la forma ireductibilă, cu numitorul pozitiv, și metode pentru sumă și produs care întorc o nouă fracție. Citiți două fracții a b c d (adică a/b și c/d, cu b, d ≠ 0) și afișați suma și produsul, câte una pe rând, în forma p/q (sau doar p când q = 1).
intrare1 2 1 3
ieșire5/6
1/6
#include <iostream>
using namespace std;
int main()
{
/* scrieți aici rezolvarea */
return 0;
}
A2
Contul bancar
Scrieți o clasă Cont, cu soldul privat, pornit de la 0, și metodele depune și retrage, care întorc true sau false. O sumă nepozitivă nu se acceptă, iar o retragere nu poate depăși soldul. Se citesc n operații D suma sau R suma (sume reale). Pentru fiecare afișați ok sau refuzat, iar la final soldul, cu două zecimale.
intrare3
D 100
R 30
R 500
ieșireok
ok
refuzat
70.00
#include <iostream>
using namespace std;
int main()
{
/* scrieți aici rezolvarea */
return 0;
}
A3
Stivă cu memorie dinamică
Scrieți o clasă Stiva de întregi care își alocă vectorul cu new în constructor (capacitate dată) și îl eliberează în destructor. Se citesc capacitatea și apoi comenzi până la sfârșitul datelor: push x, pop, top, size. pop și top afișează elementul din vârf (pop îl și scoate); pe stivă goală afișează goala. push pe stivă plină afișează plina. size afișează numărul de elemente.
intrare3
push 1
push 2
top
pop
size
ieșire2
2
1
#include <iostream>
using namespace std;
int main()
{
/* scrieți aici rezolvarea */
return 0;
}
A4
Fișiere cu ifstream și ofstream
Fișierul candidati.txt are pe fiecare rând nume medie (nume dintr-un cuvânt, medie reală). Scrieți cu ofstream în admisi.txt candidații cu media cel puțin 7, în ordinea din fișier, în forma nume medie (media cu două zecimale). Apoi recitiți admisi.txt cu ifstream și afișați numărul de admiși și conținutul fișierului.
fișier candidati.txtAna 9.5
Dan 6.99
Ion 7
ieșire2
Ana 9.50
Ion 7.00
#include <iostream>
using namespace std;
int main()
{
/* scrieți aici rezolvarea */
return 0;
}
12Sarcini de lucru
Afișați un tabel aliniat folosind setw, left, right și setfill.
Verificați experimental că setw acționează doar asupra următoarei valori afișate.
Definiți o clasă Punct cu coordonate private și metode pentru distanța până la origine.
Adăugați clasei un constructor implicit, unul cu parametri și un destructor care afișează mesaje.
Urmăriți în consolă ordinea apelurilor pentru mai multe obiecte, inclusiv într-un bloc interior.
Implementați validarea datelor în funcțiile de tip set și testați valori nepermise.
Scrieți și citiți date dintr-un fișier folosind ofstream și ifstream.
Comparați varianta C++ cu cea în C a aceluiași program și notați diferențele de lizibilitate.
13Aplicație de aprofundare
Proiect finalImplementați o clasă Vector care gestionează un tablou
alocat dinamic: constructor cu dimensiune, constructor de copiere, destructor care eliberează memoria,
metode de adăugare cu redimensionare automată, acces cu verificarea limitelor și supraîncărcarea
operatorului << pentru afișare directă cu cout. Adăugați salvarea și
încărcarea din fișier. Verificați cu mesaje în constructor și destructor că nu apar pierderi de memorie.