Articole

Generalități

Cuvântul polimorfism se referă la proprietatea unor substanțe, ființe, obiecte de a avea mai multe forme.

În contextul programării orientate pe obiecte, polimorfismul se referă la posibilitatea claselor de a avea mai multe metode cu același nume, dar cu efecte și rezultate diferite.

Supraîncărcarea funcțiilor și operatorilor sunt tratate în acest articol: www.pbinfo.ro/articole/25851/supraincarcarea-functiilor-si-a-operatorilor.

Suprascrierea funcțiilor

Suprascrierea funcțiilor (overriding) se referă la situația ca într-o ierarhie de clase să avem metode cu același nume, dar cu efecte diferite. Considerăm clasele Animal și Caine.

#include<iostream>

using namespace std;

class Animal{
	public:
		void vorbeste()
		{
			cout << "Animalul vorbeste." << endl;
		}
};

class Caine: public Animal{
	public:
		void vorbeste()
		{
			cout << "Cainele latra." << endl;
		}
};

int main(){
	Caine C;
	Animal A;
	C.vorbeste();
	A.vorbeste();
	C.Animal::vorbeste();
	// A.Caine::vorbeste(); // imposibil
}

În exemplul anterior:

• clasa Caine este derivată din clasa Animal;
• obiectul C este de tip Caine, obiectul A este de tip Animal; ambele sunt obiecte statice;
• metoda vorbeste() este disponibilă în ambele clase, fiind suprascrisă în clasa derivată
• putem accesa corespunzător pentru fiecare obiect propria metoda vorbeste()
• pentru obiectul derivat putem accesa metoda clasei de bază folosind operatorul de rezoluție: C.Animal::vorbeste(); – invers nu este posibil!

Constatăm că pentru obiectele referite static accesarea metodelor suprascrise este rezolvată elegant, putând accesa orice metodă disponibilă în obiectul curent (proprie obiectului curent sau proprie aflate mai “sus” în ierarhie).

Suprascrierea în cazul pointerilor

Să vedem cum putem accesa membri claselor de bază/derivată în cazul pointerilor. Folosind clasele definite mai sus, considerăm următorul exemplu:

Caine C;
Animal A;
Animal * p;
p = & A;
p->vorbeste(); // Animalul vorbeste.
p = & C;
p->vorbeste(); // Animalul vorbeste. (?!?)

Caine * q;
q = & C;
q->vorbeste();
// q = & A; // imposibil

Constatăm că:

• pointerul la clasa derivată (q) poate memora doar adresa unui obiect al acesteia;
• pointerul la clasa de bază (p) poate memora atât adresa unui obiect al clasei de bază, cât și adresa unui obiect al clasei derivate;
• chiar dacă pointerul memoreaza adresa unui obiect al clasei derivată, prin acel pointer se accesează metode ale clasei de bază!

Funcții virtuale

C++ oferă un mecanism prin care se alege metoda accesată printr-un pointer dinamic, la execuția programului, în funcție de clasa din care face obiectul referit de pointer (de bază sau derivată). Acest mecanism este reprezentat de funcțiile virtuale.

Declararea unei funcții (metode) virtuale este precedată de cuvântul C++ rezervat virtual în clasa de bază:

virtual tipRezultat metoda(parametri)

Exemplu:

#include<iostream>

using namespace std;

class Animal{
	public:
		virtual void vorbeste()
		{
			cout << "Animalul vorbeste." << endl;
		}
};

class Caine: public Animal{
	public:
		void vorbeste()
		{
			cout << "Cainele latra." << endl;
		}
};

int main(){
	Caine C;
	Animal A;
	Animal * p;
	p = & A;
	p->vorbeste(); // Animalul vorbeste.
	p = & C;
	p->vorbeste(); // Cainele latra. (!)
}

Constatăm că:

• p este declarat pointer la clasa de bază;
• p poate memora fie adresa unui obiect din clasa de bază, fie adresa unui obiect din clasa derivată;
• se apelează metoda corespunzătoare clasei din care face parte obiectul referit de pointer!

Încapsularea presupune și ascunderea datelor sensibile ale unui obiect. Acest lucru este necesar din cel puțin două motive:

• datele membre ale obiectului trebuie să fie consistente. De exemplu:
  • varsta unei persoane poate fi cel puțin 0, într-un interval cunoscut – nu putem avea 157 sau 1204578 de ani!
  • numitorul unei fracții trebuie să fie strict pozitiv, iar fracția trebuie să fie ireductibilă.
• obiectul este o cutie neagră. Utilizatorii săi nu-i cunosc structura internă, ci doar metodele publice prin care poate fi manipulat!

Astfel, datele membru ale unui clase sunt declarate private. Acest lucru duce la respectarea regulilor de mai sus, dar conduce totodată și la imposibilitatea de a vedea din afara clasei care este valoare unei date membru private sau de a o schimba. Aceste operații pot fi făcute prin intermediul metodelor GET și SET (getter-e și setter-e).

Definiții

O metodă GET este o metodă publică a clasei care returnează valoarea ueni date membru private.

O metodă SET este o metodă publică a clasei care atribuie unei date membru private o anumită valoare.

Observații

• getter-ele și setter-erele sunt metode publice;
• ele nu există de la sine, trebuie implementate;
• setter-ele trebuie să valideze valoarea pe care o atribuie datei private și totodată să realizeze anumite prelucrări asupra obiectului, dacă sunt necesare;
• nu există reguli stricte privind numele metodelor GET și SET. O convenție frecventă este următoarea:
  • numele metodei lor să fie similar cu cel al datei private pe care o citește/scrie, de regulă scris cu majusculă:
  • metoda GET nu are parametri și returnează valoarea datei private corespunzătoare;
  • metoda SET are ca parametru noua valoare, iar rezultatul este void sau este obiectul curent, pentru a putea înlănțui apelul metodelor.

Exemplu

În exemplul de mai jos implementăm clasa Fractie, înzestrând-o cu metode GET și SET. Folosim aceste metode la scrierea unei funcții care determină suma a două fracții.

#include <iostream>

using namespace std;

class Fractie{
	private:
		int numarator, numitor;	// proprietăți
		void Simplifica();		// metodă privată
	public:
		Fractie(int _numarator = 0, int _numitor = 1); // constructor
		Fractie(const Fractie &);	// constructor de copiere
		Fractie & Citeste();	//	metodă publică
		Fractie & Scrie();		// metodă publică
		// metode GET
		int Numarator();
		int Numitor();
		// metode SET
		Fractie & Numarator(int);
		Fractie & Numitor(int);
};

Fractie::Fractie(const Fractie & F)
{	// constructor de copiere
	numarator = F.numarator;
	numitor = F.numitor;
	Simplifica();
}

Fractie::Fractie(int _numarator /* = 0 */, int _numitor /* = 1 */)
{	// constructor
	numitor = _numitor, numarator = _numarator;
	Simplifica();
}

int Fractie::Numarator()
{
	//metoda GET
	return numarator;
}

int Fractie::Numitor()
{
	//metoda GET
	return numitor;
}

Fractie & Fractie::Numarator(int x)
{
	numarator = x;
	Simplifica();
	return * this;
}

Fractie & Fractie::Numitor(int x)
{
	// validam valoarea lui x
	if(x == 0)
	{
		cerr << "Numitor nul" << endl;
		return * this;
	}
	numitor = x;
	if(x < 0)
		numarator *= -1, numitor *= -1;
	Simplifica();
	return * this;
}

Fractie & Fractie::Citeste()
{
	// citeste numaratorul si numitorul obiectului curent
	// returnează obiectul curent
	int a , b;
	cin >> a >> b;
	// validam valorile citite
	if(b == 0)
	{
		cerr << "Numitor nul"<<endl;
		return * this;
	}
	if(b < 0)
		a = -a , b = -b;
	numarator = a, numitor = b;
	Simplifica();
	return * this;
}

Fractie & Fractie::Scrie()
{
	// afisează numaratorul si numitorul obiectului curent
	// returnează obiectul curent
	cout << numarator << " " << numitor <<endl;
	return * this;
}

void Fractie::Simplifica()
{	//metoda privata; realizeaza simplificarea fractiei merorate în obiectul curent
	int a = abs(numarator), b = abs(numitor);
	while(b)
	{
		int r = a % b;
		a = b;
		b = r;
	}
	numarator /= a;
	numitor /= a;
}

Fractie Suma(Fractie F, Fractie G)
{
	// funcție oarecare. Accesam datele private ale obiectelor prin metodele GET si SET
	int x = F.Numarator() * G.Numitor() + F.Numitor() * G.Numarator(),
		y = F.Numitor() * G.Numitor();
	Fractie R; 
	R.Numarator(x).Numitor(y); // apelam metodele SET
	return R; // s-a apelat costructorul de copiere
}

int main()
{
	Fractie a , b;
	a.Citeste(), b.Citeste();
	Suma(a , b).Scrie();
	return 0;
}

Introducere

Derivarea claselor (moștenirea) este unul dintre principiile fundamentale ale programării orientate pe obiecte. Ne permite să definim o clasă pornind de la altă clasă, creată anterior, și facilitează crearea și întreținerea aplicațiilor. Tototdată permite reutilizarea codului și micșorează timpul de implementare a programelor.

La crearea unei clase, în loc să scriem date și funcții membre complet noi, putem să precizăm că noua clasă va moșteni membri unei clase existente. Se obțin astfel ierarhii de clase.

Moștenirea are sens numai când obiectele din clasa moștenită fac parte din obiectele clasei de bază – relația dintre ele este de tipul Is A (este un/o). De exemplu:

• paralelogramul este un patrulater. Clasa Paralelogram poate fi derivată din clasa Patrulater.
• câinele este un animal. Clasa Caine poate fi derivată din clasa Animal.

Terminologie

Fie B o clasă care există deja, iar D clasa care moștenește membrii clasei B. Spunem că:

• B este clasa de bază;
• D este clasa derivată;
• clasa D s-a obținut prin derivarea clasei B;
• clasa B a fost derivată și s-a obținut clasa D;
• clasa D moștenește clasa B;
• relația de moștenire se reprezintă prin următoarea diagramă:
  

În C++, o clasă poate fi derivată pornind de la mai multe clase de bază. Totodată, specificatorii de acces cunoscuți (public, private, protected) sunt folosiți și pentru a preciza modul în care se face derivarea. Efectul lor este legat de vizibilitatea membrilor clasei de bază în clasa derivată.

Derivarea unei clase

Cea mai simplă formă de derivarea a unei clase este prezentată mai jos:

class D: public B{
	// membri noi ai clasei derivate
}

Observații:

• clasa B este clasa de bază, care trebuie să fie deja definită;
• clasa D este clasa derivată;
• specificatorul de acces folosit în exemplu, public, face ca:
  • membrii public din clasa de bază B rămân public și în clasa derivată D – pot fi accesați din afara clasei D;
  • membrii protected din clasa de bază B rămân protected și în clasa derivată D – pot fi accesați din clasa derivata D și vor putea fi acesați din alte clase vor moșteni clasa D;
  • membrii private din clasa de bază B nu pot fi accesați din clasa derivată D;
• la definiția clasei derivate, în loc de public putem folosi private sau protected. Semnificația lor va fi discutată ceva mai târziu!

Exemplu

#include<iostream>

using namespace std;

class Animal{
	private:

	protected: 
		int varsta;
	public:
		Animal(){
			varsta = 0;
			cout << "S-a nascut un animal." << endl;
		}
		~Animal(){
			cout << "Animalul a murit." << endl;
		}
		void creste()
		{
			++ varsta;
			cout << "Animalul are " << varsta << (varsta == 1 ? " an":" ani") << endl;
		}
};

class Caine: public Animal{
	public:
		Caine(){
			cout << "S-a nascut un caine." << endl;
		}
		~Caine(){
			cout << "Cainele a murit." << endl;
		}
		void latra()
		{
			for(int i = 1 ; i <= varsta ; i ++)
				cout << "Ham " ;
			cout << endl;
		}
		void creste()
		{
			++ varsta;
			cout << "Cainele are " << varsta << (varsta == 1 ? " an":" ani") << endl;
		}
};

int main(){
	Caine X;
	X.creste(); 
	X.Animal::creste();
	X.latra(); 
	X.creste();
	X.latra();
}

S-a nascut un animal.
S-a nascut un caine.
Cainele are 1 an
Animalul are 2 ani
Ham Ham 
Cainele are 3 ani
Ham Ham Ham 
Cainele a murit.
Animalul a murit.

Observații

• Animal este clasa de bază, iar Caine este clasa derivată;
• din clasa derivată (metoda latra()) am accesat proprietatea varsta din clasa de bază:
  • acest lucru a fost posibil deoarece proprietatea varsta a fost declarată protected
  • dacă ar fi fost declarată private, nu putea fi accesată din clasa derivată
• din exterior – funcția main(), pentru obiectul X de tip Caine am accesat:
  • metoda latra(), disponibilă doar în clasa derivată;
  • metoda creste(), moștenită din clasa de bază;
  • ambele metode sunt publice în clasa derivată;
• ambele clase sunt înzestrate cu constructori și destructori:
  • în cazul constructorului, mai întâi se apeleaza cel al clasei de bază, apoi cel al clasei derivate;
  • în cazul destructorului, ordinea este inversă;
• dacă în clasa de bază și în clasa derivată avem doi membri cu același nume (overriding), prioritate are cel din clasa derivată. Pentru a-l accesa pe cel din clasa de bază vom folosi operatorul de rezoluție:
  

  X.creste(); // Cainele are 1 an
  
  X.Animal::creste(); // Animalul are 2 ani

• în exemplul de mai jos se evidențiază modul în care se poate face atribuirea între o variabilă de tipul clasei de bază și una de tipul clasei derivate:
  

  int main(){
  	Caine X;
  	X.creste();  // Cainele are 1 an
  	X.latra();	 // Ham
  	Animal A;
  	A = X;
  	A.creste();	// Animalul are 2 ani
  	// X = A; eroare de sintaxă
  
  }

  
  A este de tipul Animal (clasa de bază), iar X este de tipul Caine (clasa derivată). Atunci:
  • atribuirea A = X; este corectă. În A se vor copia doar membri din X care fac parte din clasa de bază.
  • atribuirea X = A; nu este corectă. Clasa derivată conține și membri care nu aparțin clasei de bază, ce nu pot fi inițializați prin această atribuire!

Accesul la membrii claselor derivate

Accesul la membrii (date sau funcții) clasei de bază în clasa derivată se face în funcție de regulile de acces la membrii clasei de bază și în funcție de modalitatea în care s-a făcut derivarea.

Sunt trei moduri de declarare a membrilor unei clase:

• publici – public – pot fi accesați din afara clasei, dar și din interiorul ei
• protejati – protected – nu pot fi accesați din exteriorul clasei (de bază sau derivate). Pot fi accesați din interiorul clasei de bază și din interiorul claselor derivate
• privați – private – pot fi accesați numai din interiorul clasei.

Modalitățile de derivarea ale unei clase sunt:

• derivare publică:
  

  class D: public B{ … }

  • membrii publici ai clasei B rămân publici și în clasa D;
  • membrii protejați al clasei B rămân protejați în clasa D;
  • membrii privați ai clasei B sunt inaccesibili în clasa D;
• derivare protejată:
  

  class D: protected B{ … }

  • membrii publici ai clasei B devin protejați și în clasa D;
  • membrii protejați al clasei B rămân protejați în clasa D;
  • membrii privați ai clasei B sunt inaccesibili în clasa D;
• derivare privată:
  

  class D: private B{ … }

  • membrii publici ai clasei B devin privați și în clasa D;
  • membrii protejați al clasei B devin privați în clasa D;
  • membrii privați ai clasei B sunt inaccesibili în clasa D;

Generalități

Supraîncărcarea funcțiilor (eng. functions overloading) se referă la posibilitatea ca în același program să fie declarate și definite mai multe funcții cu același nume, care să difere prin parametri. La apelul unei funcții supraîncărcate, compilatorul stabilește care dintre declarații se potrivește cu apelul respectiv, comparând numărul și tipul parametrilor actuali cu cel al parametrilor formali.

Metodele unei clase, fiind funcții, pot fi supraîncărcate. Totodată, în interiorul unei clase pot fi definiți și supraîncărcați operatori (+, -, *, etc.), care permit utilizarea naturală a obiectelor, în raport cu înțelesul lor.

De exemplu, fracțiile pot fi adunate, scăzute, etc. O clasa care implementează fracții poate fi îmbogățită cu operațiile naturale de adunare, scădere, înmulțire, împărțire, dar și cu comparații, incrementări/decrementări, citire, afișare, etc.

În acest fel lucrul cu obiecte devine natural, evitând apelul explicit al unor metode care poate părea forțat, în anumite situații.

Supraîncărcarea metodelor

De știut:

• în definiția unei clase putem avea mai multe metode cu același nume;
• ele trebuie să difere prin numărul și tipul parametrilor, nu prin tipul rezultatului;
• nu se pot supraîncărca funcții care diferă numai prin tipul rezultatului!

Exemplu

În exemplul următor, definim pentru clasa Fracție două metode creste():

• una fără parametri, care va mări valoarea fracției încapsulate în obiect cu 1;
• una cu un parametru întreg n, care va mări valoarea fracției încapsulate în obiect cu n.

#include <iostream>

using namespace std;

class Fractie{
    private:
        int numarator, numitor;
    public:
		void afiseaza() /// metodă pentru afișarea fractiei
		{
			cout << numarator << "/" << numitor << endl;
		}
		Fractie(int a , int b) /// constructor
		{
			if(b < 0)
				a = -a, b = -b;
			numarator = a, numitor = b;
		}
		Fractie & creste()
		{
			numarator += numitor;
			return *this;
		}
		Fractie & creste(int n)
		{
			numarator += n * numitor;
			return *this;
		}
};

int main(){
	Fractie x(1 , 4);
	x.afiseaza();
	x.creste();
	x.afiseaza();
	x.creste(3);
	x.afiseaza();
	return 0;
}

Programul de mai sus va afișa:

1/4
5/4
17/4

Supraîncărcarea operatorilor

Putem supraîncărca aproape toți operatorii C++ predefiniți. În acest mod putem folosi operatorii și pentru tipurile definite de noi, nu doar pentru cele predefinite.

Nu putem supraîncărca operatori pentru tipurile de bază: int, double, etc.

Nu putem supraîncărca operatori care nu există. De exemplu, nu putem adăuga operatorul #.

Nu putem schimba prioritatea operatorilor.

Operatorii sunt funcții cu un nume special: cuvântul rezervat operator, urmat de simbolul operatorului pe care îl definim. La fel ca orice altă funcție, și operatorii au tip al rezultatului și listă de parametri.

Operatorii care pot fi supraîncărcați sunt:

• +, -, *, /, %
• ^, &, |, ~,
• ,
• =
• <, >, <=, >=, ==, !=,
• !, &&, ||
• ++, --
• <<, >>,
• +=, -=, /=, %=, ^=, &=, |=, *=, <<=, >>=,
• [], ()
• ->, ->*
• new, new [], delete, delete []

Următorii operatori nu pot fi supraîncărcați:

• ::, .*, ., ?:

Sunt două modalități de defini operatori pentru o clasă:

• prin intermediul metodelor;
• prin intermediul funcțiilor prietene.

Putem folosi metodele când operatorul este unar, sau când este binar și primul operand este obiect al clasei pentru care definim operatorul. Dacă operatorul este binar și primul operator nu este obiect al clasei, vom defini operatorul prin intermediul funcțiilor prietene.

Exemplu

În programul de mai jos definim o clasă Fractie în care vom defini și supraîncărca operatorul + pentru a implementa adunarea fracțiilor și adunarea fracțiilor cu întreg. Distingem următoarele cazuri:

• operația F + G, unde F și G sunt fracții, poate fi implementată atât printr-o metodă cât și ca funcție prietenă;
• operația F + n, unde F este fracție și n este număr întreg, poate fi implementată atât printr-o metodă cât și ca funcție prietenă;
• operația n + F, unde F este fracție și n este număr întreg, va fi implementată printr-o funcție prietenă.

Situația de mai sus se datorează faptului că, la implementarea operatorului ca metodă, obiectul curent, pentru care se implementează metoda, este primul operand.

#include <iostream>

using namespace std;

class Fractie{
    private:
        int numarator, numitor;
    public:
		void afiseaza() /// metodă pentru afișarea fractiei
		{
			cout << numarator << "/" << numitor << endl;
		}
		Fractie(int a = 0, int b = 1) /// constructor
		{
			if(b < 0)
				a = -a, b = -b;
			numarator = a, numitor = b;
		}
		Fractie operator+ (Fractie F)
		{
			Fractie R;
			R.numarator = numarator * F.numitor + numitor * F.numarator;
			R.numitor = numitor * F.numitor;
			return R;
		}
		Fractie operator+ (int n)
		{
			Fractie R;
			R.numarator = numarator + n * numitor;
			R.numitor = numitor;
			return R;
		}
		friend Fractie operator + (int n, Fractie F)
		{
			Fractie R;
			R.numarator = F.numarator + n * F.numitor;
			R.numitor = F.numitor;
			return R;
		}
};

int main(){
	Fractie X(1 , 4), Y(2, 3);
	Fractie R = X + Y;
	R.afiseaza();
	R = X + 2;
	R.afiseaza();
	R = 2 + X;
	R.afiseaza();
	return 0;
}

Programul de mai sus va afișa:

11/12
9/4
9/4

Generalități

În programarea procedurală, un program era alcătuit din două componente distincte: date și funcții; funcțiile prelucrează datele la care au acces, prin intermediul parametrilor sau în alt mod.

Programarea orientată obiect – POO (sau Object Oriented Programming – OOP) este o modalitate de proiectare a programelor în care datele prelucrate și operațiile cu acestea sunt încapsulate în aceeași structură, numită obiect. Funcțiile care fac parte dintr-un obiect au acces la datele care caracterizează acel obiect, iar un program este alcătuit din mai multe obiecte, care interacționează.

Programarea orientată pe obiecte se bazează pe următoarele principii fundamentale:

• încapsulare = mecanismul prin care atât datele, cât și funcțiile sunt plasate în aceeași structură, numită clasă și stabilirea nivelului de acces la conținutul acesteia;
• abstractizare = identificarea datelor și funcțiilor relevante pentru o anumită clasă;
• moștenire = proprietatea claselor de a prelua date și metode ale unor clase definite anterior. Clasa inițială se numește clasă de bază, iar cea nouă se numește clasă derivate;
• polimorfism = posibilitatea ca atât clasa de bază, cât și clasa derivată să conțină metode cu același nume, dar diferite ca funcționalitate.

Noțiunile de clasă și obiect

Clasa este un tip de date, similar cu struct, care conține atât câmpuri de tip dată (numite proprietăți), cât și câmpuri de tip funcție (numite și metode). Câmpurile clasei (proprietăți sau metode) se mai numesc membri ai clasei. Astfel avem, date membre și funcții membre.

Obiectul reprezintă o dată de tipul clasei – de exemplu o variabilă. Declararea unei variabile de acest tip se mai numește instanțiere a clasei. Spunem că obiectul este o instanță a clasei.

Pentru membrii unei clase (date sau metode) se precizează anumite caracteristici, numite modificatori (specificatori) de acces, care stabilesc cum se face accesul la acestea:

• private – interzic accesul la date și metode în afara clasei;
• public – permit accesul la date și metode din afara clasei;
• protected – interzic accesul din afara clasei, dar îl permit din clasele derivate – are sens în contextul derivării claselor.

Exemplu

#include <iostream>

using namespace std;

class Fractie{
    private:
        int numarator, numitor;
    public:
		void afiseaza(){
			cout << numarator << "/" << numitor << " ";
		}
		void seteaza(int , int);
};

void Fractie::seteaza(int a , int b){
    numarator = a , numitor = b;
}

int main(){
	Fractie F;
	F.seteaza(3 , 4);
	F.afiseaza();
	/// F.numarator = 7; //eroare, data este privata

    return 0;
}

În exemplul de mai sus:

• Fractie este numele clasei;
• F este numele obiectului – instanță a clasei;
• clasa are două date membre: numarator și numitor. Ele sunt private – nu pot fi accesate din exteriorul clasei;
• clasa are două funcții membre: seteaza(), care dă valori datelor membre și afiseaza(), care afișează datele membre în forma specifită unei fracții ordinale. Ele sunt publice.

Observații

• clasele se definesc similar cu structurile
  

  class Fractie{
  	/// …
  
  };

  
  De fapt, diferențele dintre clase și structuri sunt reduse. În acest moment putem observa că accesul la câmpurile unei structuri este implicit public, iar accesul la membrii unei clase este implicit privat.

• accesul la membri clasei, indiferent dacă sunt date sau funcții, se face asemănător cu cel al câmpurilor unei structuri, prin operatorul de acces direct . (punctul), sau, în cazul pointerilor la clase, prin operatorul de acces indirect ->.
  

  Fractie X;
  
  X.afiseaza();

• obiectele unei clase se declara la fel cum se declară variabilele de orice tip
  notextile.

  Fractie x, y; /// două obiecte
  
  Fractie V[ 10 ]; /// un tablou cu 10 elemente de tip obiect
  
  Fracte * p; /// pointer la obiect. Obiectul încă nu există!!

  
  Crearea obiectului se numește instanțiere a clasei, iar obiectl este o instanță a clasei.

• la fel ca în cazul structurilor, având două obiecte ale aceleiași clase, se pot realiza atribuiri. Trebuie însă știut că este posibil ca rezultatul atribuirii să nu fie cel așteptat!
  

  Fractie x , y;
  
  x.seteaza(3 , 4);
  
  y = x;
  
  y.afiseaza();
  
  

• putem declara pointeri la obiecte. Obiectele adresate de pointeri pot fi statice sau dinamice, iar accesul la datele și funcțiile membre se face prin intermediul operatorului de acces indirect ->
  

  Fractie x , * p;
  
  x.seteaza(3 , 4);
  
  p = & x;
  
  p->afiseaza();
  
  

• metodele unei clase pot fi descrise în modul următor:
  • plasăm în interiorul clasei definiția metodei, obținând o metodă inline – în exemplul de mai sus metoda afiseaza() a fost scrisă în acest mod
  • plasăm în interiorul clasei numai declarația (prototipul) metodei, iar definiția o plasăm în exteriorul clasei. În exemplul de mai sus am scris în acest mod metoda seteaza(). Pentru a preciza că este vorba despre o metodă a clasei și nu o funcție oarecare se folosește operatorul de rezoluție ::
    

    void Fractie::seteaza(int a , int b){
        numarator = a , numitor = b;
    
    }

  • un avantaj al metodelor inline este că orice apel al ei este înlocuit cu secvanța de instrucțiuni corespunzătoare. Această abordare conduce la economie de timp, dar și la un necesar mai mare de memorie.

Constructori

Constructorul reprezintă un mecanism prin care datele membre ale unui obiect dintr-o clasă primesc valori la instanțierea (declararea/crearea) obiectului.

• constructorii sunt metode (funcții membre) ale clasei și se apelează la instanțierea obiectului
• constructorul:
  • este o metodă a clasei
  • are același nume cu clasa
  • este o funcție fără tip; la declarare/definire în locul tipului funcție nu se scrie nimic, nici măcar void
• o clasă poate avea mai mulți constructori, care diferă prin numărul și tipul parametrilor
• constructorii sunt funcții; blocul lor poate conține orice fel de instrucțiuni care reflectă logica clasei pe care o definim!

Exemplu

class Fractie{
    private:
        int numarator, numitor;
        void simplifica(){
        	int a = numarator, b = numitor , r;
            while(b)
            	r = a % b, a = b, b = r;
            numarator /= a, numitor /= a;
        }
    public:
		void afiseaza(){
			cout << numarator << "/" << numitor << endl;
		}
		void seteaza(int a , int b){
            numarator = a , numitor = b;
        }
		Fractie(){
			numarator = 0, numitor = 1;
		}
		Fractie(int a){
			numarator = a, numitor = 1;
		}
		Fractie(int a , int b){
			if(b == 0)
				b = 1;
			numarator = a, numitor = b;
            simplifica();
		}
};

int main(){
	Fractie x;
	x.afiseaza();
	Fractie y(3);
	y.afiseaza();
	Fractie z(3 , 2);
	z.afiseaza();
	return 0;
}

Observații

• în lipsa unui constructor definit de programator, se va apela constructorul implicit – el permite declararea obiectelor, alocând memorie pentru ele;
• dacă o clasă are constructor cu parametri, constructorul implict nu mai există. În consecință, nu se pot declara obiecte fără parametri, ceea ce este de multe ori necesar. De aceea, dacă o clasă are constructor, este necesar să aibă și constructor fără parametri, prin care un datele membre ale obiectului declarat să primească valorile pe care le consideram implicite.

Constructor de copiere

Constructorul de copiere creează un obiect inițilizândul cu un alt obiect, din aceeași clasă, care există deja. El se folosește pentru:

• inițializarea unui obiect cu un alt obiect
• transmiterea prin valoare a unui obiect ca parametru pentru o funcție
• copierea unui obiect returnat de o funcție

Clasele au un constructor de copiere implicit, care realizează copierea bit-cu-bit a conținutului obiectului. Acest mod de copiere nu este corect atunci când obiectul conține date alocate dinamic, caz în care este mecesară definirea unui constructor de copiere explicit.

Sintaxa este:

NumeClasa (const NumeClasa &); 

Exemplu:

Fractie(const Fractie & F)
{
	numarator = F.numarator();
    numitor = F.numitor();
    simplifica();
}

Destructor

Destructorul este o metodă publică care se apelează la eliminarea din memorie a unui obiect. O clasă poate avea un singur destructor, iar numele lui este identic cu al metodei, dar precedat de caracterul ~. Destructorul, similar cu destructorul, este o funcție fără tip. Destructorul nu are parametri.

Exemplu

class Fractie{
    private:
        int numarator, numitor;
    public:
		void afiseaza(){
			cout << numarator << "/" << numitor << endl;
		}
		...
		~Fractie(){
			cout << "Fractia " << numarator << "/" << numitor << " a fost eliminata." << endl;
		}
};

int main(){
	Fractie x(1 , 4);
	x.afiseaza();

	return 0;
}

Regula celor Trei

Funcții prietene

Uneori este necesar ca din interiorul unor funcții care nu sunt metode ale unui obiect să accesăm membrii privați ai acestuia. Acest lucru poate fi realizat prin intermediul funcțiilor prietene. Ele:

• sunt declarate în interiorul clasei; prototipul lor este precedat de cuvântul cheie friend
• funcția prieten are un parametru de tipul clasei; în funcție se pot accesa membrii privați ai acesteia
• funcțiile prietene nu sunt metode ale clasei; ele nu pot accesa direct membrii clasei, ci numai membrii parametrului de tipul clasei

Exemplu:

class Fractie{
    private:
        int numarator, numitor;
    public:
		...
		friend void Afiseaza(Fractie F);
};

void Afiseaza(Fractie F)
{
	cout << F.numarator << "/" << F.numitor << endl;
}

int main(){
	Fractie x(1 , 4);
	Afiseaza(x);

	return 0;
}

Cuvântul cheie this

În definiția metodelor unei clase, cuvântul cheie this reprezintă un pointer către obiectul curent.

Este necesar în următoarele situații:

• parametrii unor metode au același nume cu datele membre. Exemplu: clasa fracție conține câmpul numarator și o metodă are un parametru cu același nume, atunci parametrul poate fi referit prin identificatorul numarator, iar câmpul prin expresia this->numarator sau (*this).numarator;
• uneori este necesar ca o metodă să returneze obiectul curent, sau o referință la obiectul curent;

Exemplu:

class Fractie{
    private:
        int numarator, numitor;
    public:
		...
		Fractie & creste(int n)
		{
			this->numarator += n * this->numitor; // aici this nu este necesar
			return * this;
		}
		friend void Afiseaza(Fractie F);
};

void Afiseaza(Fractie F)
{
	cout << F.numarator << "/" << F.numitor << endl;
}

int main(){
	Fractie x(1 , 4);
	Afiseaza(x);
	x.creste(2).creste(3);
	Afiseaza(x);
	return 0;
}

Un exemplu complet

Programul de mai jos implementează clasa Fractie și reprezintă o soluție pentru problema #spfractii :

• respectă principiul încapsulării;
• conține:
  • proprietăți (private);
  • metode private;
  • metode publice;
  • constructor;
  • constructor de copiere;
  • funcții prietene;
  • this. Prin intermediul său, metodele vor returna obiectul curent, fapt ce permite înlănțuirea acestora – vezi apelul funcției Produs().

#include <iostream>

using namespace std;

class Fractie{
	private:
		int numarator, numitor;	// proprietăți
		void simplifica();		// metodă privată
	public:
		Fractie(int _numarator = 0, int _numitor = 1); // constructor
		Fractie(const Fractie &);	// constructor de copiere
		Fractie & citeste();	//	metodă publică
		Fractie & scrie();		// metodă publică
		friend Fractie Suma(Fractie , Fractie);	// functie prietena
		friend Fractie Produs(Fractie , Fractie);	// functie prietena
};

Fractie::Fractie(const Fractie & F)
{	// constructor de copiere
	numarator = F.numarator;
	numitor = F.numitor;
	simplifica();
}

Fractie::Fractie(int _numarator /* = 0 */, int _numitor /* = 1 */)
{	// constructor
	numitor = _numitor, numarator = _numarator;
	simplifica();
}
Fractie & Fractie::citeste()
{
	// citeste numaratorul si numitorul obiectului curent
	// returnează obiectul curent
	cin >> numarator >> numitor;
	return * this;
}

Fractie & Fractie::scrie()
{
	// afisează numaratorul si numitorul obiectului curent
	// returnează obiectul curent
	cout << numarator << " " << numitor <<endl;
	return * this;
}

void Fractie::simplifica()
{	//metoda privata; realizeaza simplificarea fractiei merorate în obiectul curent
	int a = numarator, b = numitor;
	while(b)
	{
		int r = a % b;
		a = b;
		b = r;
	}
	numarator /= a;
	numitor /= a;
}

Fractie Suma(Fractie F, Fractie G)
{
	// funcție prietenă. Putem accesa datele private ale obiectelor F , G
	int x = F.numarator * G.numitor + F.numitor * G.numarator,
		y = F.numitor * G.numitor;
	Fractie Rez(x , y); // s-a apelat constructorul pentru crearea obiectului. Aici s-a făcut simplificarea
	return Rez; // s-a apelat costructorul de copiere
}

Fractie Produs(Fractie F, Fractie G)
{	
	// funcție prietenă. Putem accesa datele private ale obiectelor F , G
	int x = F.numarator * G.numarator,
		y = F.numitor * G.numitor;
	return Fractie(x , y); // se apelează constructorul de copiere. Aici se face simplificarea
}

int main()
{
	Fractie A , B;
	A.citeste(), B.citeste();
	Fractie S = Suma(A , B);
	S.scrie();
	Produs(A , B).scrie();
	return 0;
}