3.

Clase: problema alocarii memoriei

Fata de setul de functii pentru gestionarea memoriei din C (malloc(), etc.), operatorii new si delete sînt construiti
astfel încît sa valorifice avantajele limbajului C++. Diferentele importante între malloc() si new sînt:
. Functia malloc() nu cunoaste la ce va fi folosita memoria alocata. De exemplu, cînd este alocata memorie
pentru mai multi int, va trebui sa exprimam lungimea corecta cu ajutorul functiei sizeof (int). Din contra, new cere
numai precizarea tipului; functia sizeof() este implicit apelata de compilator.
. Singurul mod de a initializa memoria alocata de malloc() este folosirea lui calloc() (ce aloca memorie si o
seteaza la o anumita valoare). Operatorul new cheama implicit constructorul obiectului pentru care este
memorata memorie, constructor care poate fi însotit de argumente.
O comparatie analoaga poate fi facuta si între free() si delete. Apelul constructorului si a destructorului unui
obiect au o serie de consecinte. Multe probleme apar din cauza incorectei alocari a memorie, a lipsei de
memorie, a depasirilor, etc. C++ nu rezolva magic aceste probleme, dar pune la dispozitia programatorului o
serie de mijloace pentru depasirea lor.
4.1. Clase cu date de tip pointer
Sa revenim la clasa Person:
class Person
{ public: //constructori si destructor
Person(); Person( char const *n, char const *a, char const *p);
~Person();
void setname (char const *n);
void setaddress (char const *a);
void setphone (char const *p);
char const *getname (void) const;
char const *getaddress (void) const;
char const *getphone (void) const;
private: //datele
char *name;
char *address;
char *phone;
};
În aceasta clasa destructorul este necesar pentru a preveni ca memoria, odata alocata pentru cîmpurile name,
address si phone, sa nu devina inutilizabila la disparitia obiectului. În exemplul urmator este creat un obiect
Person iar datele sînt listate. Dupa terminarea functiei main(), memoria alocata va fi eliberata.
Person:~Person ()
{ delete name; delete address; delete phone; }
void main()
{
Person kk ("Karel", "Berlin", "14999078");
*bill = new Person ("Bill", "Whashington", "0912021423045");
printf ("%s, %s, %s\n", kk.getname(), kk.getaddress(), kk.getphone());
printf ("%s, %s, %s\n", bill->getname(), bill->getaddress(), bill->gerphone());
delete bill;
}
Memoria alocata pentru obiectul kk este automat eliberata la terminarea lui main(). Variabila bill este un pointer,
iar un pointer, chiar în C++, nu este obiectul însusi. De aceea memoria alocata de obiectul pointat de bill trebuie
eliberata explicit. Operatorul delete asigura si apelul destructorului, eliberînd memoria ocupata de cele trei
cîmpuri ale obiectului pointat.
4.2. Operatorul de asignare
Variabilele de tip struct sau class pot fi direct asignate în C++ la fel ca variabilele struct din C. Actiunea implicita
implica copierea bit cu bit.
void printperson (Person const &p)
{ Person tmp;
tmp = p;
printf ("Name: %s\n Address: %s\n Phone %s\n", tmp.getname(), tmp.getaddress(), tmp.getphone());
}
Executia acestei functii pas cu pas este urmatoarea:
. Functia printperson () asteapta o referinta la un obiect Person (parametrul p).
. Functia defineste un obiect local tmp. Este deci apelat constructorul implicit al clasei Person, ce seteaza
pointerii name, address si phone pe zero (daca a fost definit astfel).
. Obiectul referit de p este copiat în tmp (sizeof (Person) biti sînt copiati în tmp).
. Apare o situatie periculoasa: valorile din p sînt pointeri, ce pointeaza o anumita zona de memorie; dupa
operatiunea de asignare, aceasta memorie este pointata de doua obiecte: p si tmp.
. Situatia periculoasa devine acuta dupa terminarea functiei printperson (). Obiectul tmp este distrus.
Destructorul clasei Person elibereaza memoria pointata de pointerii name, address si phone din obiectul tmp;
dar aceeasi memorie este folosita si de p!!. În acest fel se pierd datele (în fond stringurile ramîn în memorie,
pointerii catre ei ramîn la aceeasi valoare, dar o noua alocare ulterioara va putea folosi acea zona de memorie
ocupata de stringuri.)
În concluzie: orice clasa ce contine un constructor si un destructor , precum si cîmpuri pointeri pentru adresarea
memoriei alocate, este un candidat potential pentru necazuri !.
Redefinirea operatorului de asignare
De fapt, modul corect de asignare a unui obiect Person cu un alt obiect este nu de a copia continutul bit cu bit, ci
de a crea un obiect echivalent, care sa aiba memorie alocata proprie, dar care sa contina aceleasi srtinguri.
Exista mai multe solutii pentru asta. Una din ele consta în definirea unei functii speciale pentru asignarea
obiectelor Person. Iata un exemplu:
void Person::assign (Person const &other)
{// sterge vechea memorie utilizata
delete name; delete address; delete phone;
// copie datele
name = strdup (other.name);
address = strdup (other.address);
phone = strdup (other.phone);
}
Astfel putem redefini functia printperson():
void printperson (Person const &p)
{ Person tmp;
tmp.assign (p);
printf ("Name: %s\n Address: %s\n Phone %s\n", tmp.getname(), tmp.getaddress(), tmp.getphone());
}
Aceasta solutie cere ca programatorul sa foloseasca o functie membru specific în loc de operatorul '='. În
general, problema reasignarii operatorilor se rezolva în C++ folosind operatorul de reacoperire. Reacoperirea
operatorului de asignare este poate cea mai întîlnita forma de reasignare. Totusi, faptul ca C++ permite
reacoperirea nu înseamna ca aceasta facilitate trebuie folosuita tot timpul. Citeva regului utile sînt:
. Reacoperirea operatorului ar trebui folosita în situatia în care un operator are o actiune definita, dar aceasta
actiune nu este dorita sau are si efecte secundare negative (vezi cazul precedent).
. Reacoperirea poate fi folosita cînd utilizarea operatorului este comuna si nu apar ambiguitati introduse prin
redefinire. De exemplu, redefinirea operatorului '+' pentru a lucra si cu numere complexe.
. În toate celelalte cazuri este preferabila definirea unei functii membru.
Functia operator=()
Pentru a implementa reacoperirea în cadrul unei clase, clasa respectiva va mai contine o functie public cu
numele acelui operator. Se va crea astfel o functie corespunzatoare. De exemplu, pentru reacoperirea
operatorului '+' va fi definita functia operator+(). Numele consta din cuvîntul cheie operator însotit de simbolul
operatorului. În cazul nostru avem (redefinirea lui '='):
class Person
{ public:
....
void operator= (Person const &other);
....
private:
...
};
void Person::operator= (Person const &other)
{// sterge vechea memorie utilizata
delete name; delete address; delete phone;
// copie datele
name = strdup (other.name);
address = strdup (other.address);
phone = strdup (other.phone);
}
Aceasta implementare este doar o prima versiune; o versiune mai buna va fi prezentata ulterior. Apelul acestei
functii (similara cu functia assign () definita anterior) se face astfel:
Person pers ("Frank", "Londra", "41526399"), copy;
copy = pers // un prim tip de apel
copy.operator= (pers); // al doilea tip de apel
Folositi primul tip de apel, ca recomandare.
4.3. Pointerul this
Asa cum am vazut, o functie membru al unei clase este apelata în contextul explicit al unui obiect al acelei clase;
exista deci un 'substrat' implicit al functiei. C++ defineste cuvîntul cheie this, pentru adresarea acestui substrat
(this nu este accesibil în contextul functiilor membru declarate static, nediscutate înca). Cuvîntul cheie this este o
variabila pointer, care va contine întotdeauna adresa obiectului în chestiune. Pointerul this este implicit declarat
în fiecare functie membru (fie ea private sau public), ca si cum în fiecare functie ar exista declaratia: extern
<nume clasa> *this; . O functie membru, ca setname(), ar putea fi implementata în doua moduri, folosind sau nu
pointerul this;
//alternativa 1: folosirea implicita a lui this
void Person::setname (char const *n)
{ delete name; name = strdup (n); }
// alternativa 2: folosirea explicita a lui this
void Person::setname(char const *n)
{ delete this->name; this->name = strdup (n); }
Exista situatii cînd este necesara folosirea explicita a lui this.
Prevenirea distrugerii proprii cu this.
Asa cum am vazut, operatorul '=' poate fi redefinit în clasa Person astfel încît sa se obtina, prin asignare, doua
copii ale aceluiasi obiect. Atît timp cît cele doua variabile sînt diferite, prima versiune a functiei operator=() va
functiona corect: memoria pentru obiectul asignat este eliberata, dupa care este alocata din nou pentru
memorarea noilor stringuri. Totusi, cînd un obiect este asignat lui însusi, (autoasignare), apare urmatoarea
problema: deoarece primul pas este eliberarea memorie, se pierde chiar continutul datelor obiectului respectiv.
Iata un exemplu:
void fubar (Person const &p)
{ p = p; }
Aici se vede clar ca se poate întîmpla ceva gresit, dar pot exista si autoasignari mai putin evidente:
Person one, two, *pp;
pp = &one;
......
*pp = two;
.....
one = *pp;
Problema autoasignarii poate fi rezolvata cu ajutorul pointerului this. În implementarea operatorului reacoperit '='
se va testa la început daca obiectul din dreapta nu este acelasi cu obiectul curent; daca e asa, nu se face nimic.
Obtinem versiunea îmbunatatita:
void Person::operator= (Person const &other)
{ if (this != &other)
{delete name; delete address; delete phone;
name = strdup (other.name);
address = strdup (other.address);
phone = strdup (other.phone);
}
}
(Exista însa si o varianta si mai buna !)
Asociativitatea operatorilor si this
Sintaxa lui C++ spune ca asociativitatea operatorului de asignare este de la dreapta la stînga, adica în
instructiunea a = b = c; expresia b = c este evaluata prima, iar rezultatul este asignat lui a. Implementarea
operatorului de reacoperire nu permite totusi constructii de acest fel., deoarece functia membru este de tip void.
In concluzie, implementarea precedenta rezolva problemele de alocare, dar nu si pe cele sintactice. Problema
sintactica poate fi ilustrata astfel. Cînd rescriem expresia a = b = c sub forma explicita de apel de functie
obtinem: a.operator= (b.operatot= (c)); sintactic este gresit deoarece expresia b.operator=(c) întoarce void, iar
clasa Person nu contine functia membru operator=(void). Problema poate fi depasita folosindu-l pe this. Functia
de reacoperire esteapta ca argument o referinta la un obiect Person; în acelasi timp poate returna o referinta la
un asemenea obiect. Aceasta referinta poate fi folosita ca argument pentru o asignare ulterioara. Este o
obisnuita de a lasa ca functia de reacoperire a asignarii sa întoarca o referinta la obiectul curent (adica *this), o
referinta de tip const. În final, versiunea cea mai buna a operatorului reacoperit de asignare va fi:
class Person
{ public:
.....
Person const &operator= (Person const &other)
.....
};
Person const &Person::operator= (Person const &other)
{ if (this != &other)
{delete name; delete address; delete phone;
name = strdup (other.name);
address = strdup (other.address);
phone = strdup (other.phone);
}
return (*this) // întoarce obiectul curent
}
4.4. Constructorul copy: Initializare si asignare
Sa definim pentru început clasa String:
class String
{ public: String();
String (char const *s);
~String ();
String const &operator= (String const &other);
void set (char const *data); //interfata
char const *get (void);
private: char *str;
}
. Clasa contine un pointer char * str pentru adresarea unei zone de memorie. Din acest motiv clasa are un
constructor, care va pune pointerul catre zero, si un destructor, care va elibera memoria.
. Din acelasi motiv, clasa are si un operator reacoperit (cel de asignare). Codul acestei functii poate arata astfel:
String const &String::operator= (String const &other)
{ if (this != &other)
{ delete str;
str = strdup (other.str); }
return (*this);
}
. Clasa mai are si un constructor cu un argument, care va fi un sir
. Interfata va avea rolul de a seta pointerul clasei catre zona de memorie unde se va afla sirul dorit (argumentul
functiei set ()). Un posibil apel: String a ("Hello World \n");
Fie urmatorul cod:
String a ("Hello World \n"), // instructiunea 1
b, //instructiunea 2
c = a; //instructiunea 3
int main()
{ b = c ; //instructiunea 4
return (0);
}
. Instructiunea 1 este o initializare. Obiectul a este initializat cu sirul "Hello World", apelîndu-se constructorul cu
un argument. Aceasta forma este identica cu String a = "Hello World\n". Desi apare aici operatorul '=', nu este o
asignare, ci o initializare, (deci apelul unui constructor).
. În instructiunea 2 este creat tot un obiect String. Nefiind nici un argument, este chemat constructorul implicit.
. În instructiunea 3 este creat obiectul c care este initializat cu obiectul a . Aceasta forma de initializare nu a mai
fost prezentata pîna acum. Deoarece putem rescrie instructiunea în forma String c (a); , aceasta initializare
sugereaza ca este apelat un constructor, cu un argument referinta la un obiect de tip String. Asemenea
constructori sînt des întîlniti în C++ si sînt numiti constructori copy.
. În instructiunea 4 un obiect este asignat altuia. Nu este creat nici un obiect nou, deci este apelata functia de
reacoperire.
Regula de baza ce trebuie retinuta: Oricînd este creat un obiect, este apelat un constructor !.
Regulile constructorului sînt:
. Nu întoarce nici o valoare
. Are acelasi nume ca si clasa
. Lista de argumente poate fi dedusa din cod; argumentul este fie prezent între paranteze, fie urmeaza unui '='
În concluzie, pentru instructiunea 3 clasa String trebuie sa contina un constructor copy:
class String
{ public:
.....
String (String const &other);
.....
};
// definitia constructorului copy
String::String (String const &other)
{ str = strdup (other.str); }
Actiunea constructorului copy este identica cu cea a operatorului de asignare reacoperit: un obiect este duplicat,
astfel încît sa aiba propria zona de memorie. Totusi el este mai simplu din urmatoarele puncte de vedere:
. Nu trebuie sa dealoce zona de memorie alocata anterior pentru ca obiectul în chestiune este creat chiar atunci
(nu are asa ceva)
. Nu trebuie sa verifice auto-duplicarea, deoarece nici o variabila nu se poate initializa cu ea însasi.
În afara acestor utilizari ale constructorului copy, mentionate mai sus, el mai poate avea si alte functii, legate de
faptul ca este apelat întotdeauna cînd este creat un obiect si initializat cu alt obiect (chiar daca noul obiect este o
variabila ascunsa sau doar temporara):
. Cînd o functie are ca argument un obiect, în loc de un pointer sau o referinta la obiect, C++ apeleaza
constructorul copy pentru a pasa o copie a acelui obiect ca argument. Acest argument, de obicei creat în stiva,
este în fond un nou obiect, creat si initializat cu datele obiectului pasat ca argument. Iata un exemplu:
void func (String s)
{ puts (s.get ()); }
int main ()
{ String hi ("Hello World");
func (hi);
return (0);
}
În acest cod hi nu este tratat de functia func(), desi este argumentul ei. Se creeaza o variabila temporara în stiva
folosindu-se constructorul copy. Aceasta variabila este cunoscuta de functie sub numele de s.
. Constructorul copy este de asemeni apelat implicit în momentul în care o functie returneaza un obiect. Iata un
exemplu:
String getline ()
{ char buf [100]; // defineste zona tampon
gets (buf); //citeste zona tampon
String ret = buf // converteste zona în String
return (ret); / / o returneaza
}
Un obiect String ascuns este initializat cu valoarea întoarsa ret (folosind constructorul copy) si este returnata de
functie. Variabila locala ret dispare dupa terminarea actiunii functiei getline().
Pentru a demonstra ca constructorul copy nu este chemat în orice situatie, iata urmatorul exemplu. Rescriem
functia getline astfel:
String getline()
{ char buf [100];
gets (buf);
return (buf);
}
Codul este corect, desi valoarea returnata nu se suprapune prototipului String. În aceasta situatie, C++ înceraca
sa converteasca char * la un String: acest lucru este posibil daca este dat un constructor ce asteapta un char *
ca argument. Deci aici va fi apelat constructorul cu un argument char *.
Similaritati între constructorul copy si functia operator=()
. Duplicarea datelor (private) apare si în constructorul copy si în functia de reacoperire
. Dealocarea memoriei ocupate apare în functia de reacoperire si în destructor.
Cele doua actiuni (duplicarea si dealocarea) pot fi codate în doua functii primitive, de exemplu copy () si destroy
(), ce vor fi folosite în constructorul copy, în functia de reacoperire si în destructor. Rescriem, de exemplu, clasa
Person:
class Person
{ public:
Person (Person const &other)
~Person ();
Person const &operator= (Person const &other);
....
private:
char *name, *address, *phone;
void copy (Person const &other);
void destroy (void);
};
//implementarea pentru copy() si destroy()
void Person::copy (Person const &other)
{ name=strdup (other.name);
address=strdup (other.address);
phone=strdup (other.phone);
}
void Person::destroy ()
{ delete name; delete address; delete phone; }
În final rescriem si cele trei functii public în care se aloca (dealoca ) memorie:
Person::Person (Person const &other)
{ copy (other); } //copiere neconditionata
Person::~Person ()
{ destroy (); } //dealocare neconditionata
Person const &Person::operator= (Person const &other)
{ if (this != &other)
{ destroy (); copy (other); }
return (*this);
}
4.5. Alte exemple de reacoperire a operatorilor
Acoperirea operatorului [ ]
Ca exemplu pentru reacoperire, prezentam o clasa ce va reprezenta un tablou de întregi. Indexarea elementelor
se face cu operatorul standard [ ], dar îl vom reacoperi pentru a efectua si o verificare contra depasirilor:
int main ()
{ Intarray x (20); //20 de întregi
for (register int i = 0; i < 20; i ++)
x [i] = i * 2; //asigneaza elementele
for (i = 0; i <= 20; i++)
printf ("Pentru index %d: valoarea %d\n", i, x [i]);
return (0);
}
În acest exemplu se creeaza un tablou de 20 de întregi. Elementele lui pot fi asignate sau identificate. Codul va
produce eroare, datorita faptului ca ultimul for va produce o depasire (este adresat x[20], desi ultimul element
este x[19]). Definitia clasei este:
class Intarray
{ public: Intarray (int sz = 1); // constructor implicit
Intarray (Intarray const &other);
~Intarray ();
Intarray const &operator= (Intarray const &other);
//interfata
int &operator[] (int index);
private:
int *data, size;
};
Facem urmatoarele observatii:
. Clasa are un constructor cu un argument implicit, specificînd dimensiunea tabloului. El serveste si ca un
constructor implicit, compilatorul punînd dimensiunea 1 daca nu apare nici un argument
. Clasa utilizeaza un pointer intern pentru adresarea memoriei: deci este necesar un constructor copy, o functie
de reacoperire a asignarii si un destructor
. Interfata este definita ca o functie ce întoarce o referinta la un întreg. Aceasta permite ca expresii de tip x[10] sa
fie folosite si în partea stînga, si în partea dreapta a unui operator de asignare. Putem deci utiliza aceeasi functie
si pentru setarea unei valori si pentru adresarea ei
Implementarea functiilor:
Intarray::Intarray (int sz)
{ if (sz < 1) //verifica dimensiunea legala
{ printf ("Tablou: dimensiunea trebuie sa fie >= 1, nu %d!\n", sz);
exit (1);`}
size = sz;
data = new int [sz];
}
//constructorul copy
Intarray::Intarray (Intarray const &other)
{ size = other.size;
data = new int [size]; //creeaza noua zona
for (register int i = 0; i < size; i++)
data [i] = other.data [i] //copieaza valorile obiectului other
}
//reacoperirea asignarii
Intarray const &Intarray::operator= (Intarray const &other)
{ if (this != &other)
{ size = other.size;
delete [] data; // elibereaza vechea memorie
data = new int [size];
for (register int i = 0; i < size; i++)
data [i] = other.data [i];
}
return (*this);
}
// functia interfata = reacoperirea operatorului []
int &Intarray::operator[] (int index)
{ // verifica limitele tabloului
if (index < 0 || index >= size)
{ printf ("Tablou: depasire de margini, indexul=%d trebuie sa fie între 0 si %d\n", index, size -1);
exit (1); }
return (data [index]);
}
Adaptarea operatorilor cin, cout, cerr
Vom prezenta modul în care o clasa poate fi adaptata penru utilizarea device-urilor cout , cerr si a operatorului
<< (pentru cin si operatorul >> se va face similar). Implementarea reacoperirii operatorului << în contextul celor
doua device-uri se face în cadrul clasei de baza pentru cout sau cerr, care este ostream. Aceasta clasa este
declarata în fisierul header iostream.h si defineste operatorul numai pentru tipurile de baza, int, char*, etc. (cîte o
definitie de reacoperire pentru fiecare tip). Sa redefinim, de exemplu, operatorul pentru a putea procesa o noua
clasa, Person, adica sa putem scrie:
Person kr ("John", "Chicago", "9087798");
cout << "Numele, adresa si telefonul persoanei kr:\n" << kr << '\n';
Instructiunea cout << kr implica operatorul << si cei doi noi operanzi: unul de tip ostream& si unul de tip
Person&. Actiunea dorita este definita cu functia operator<< () care cere o lista de doua argumente:
//declaratie în fisierul person.h
extern ostream &operator<< (ostream &, Person const &);
// definitia din fisierul sursa
ostream &operator<< (ostream &ostream, Person const &pers)
{
return (stream << "Numele: " << pers.getname ()
<< "Adresa: " << pers.getaddress ()
<< "Telefon: " << pers.getphone ()
);
}
Observatii:
. Functia trebuie sa întorca o referinta la un obiect ostream pentru a putea folosi operatorul 'în lant'
. Cei doi operanzi ai operatorului << reprezinta cele doua argumente ale functiei de reacoperire