InfoAcademy Adonis Butufei

9 CLASE SI OBIECTE

CUPRINS
9 CLASE SI OBIECTE.................................................................................................................................2
9.1 Clase, membri si obiecte.....................................................................................................................2
9.1.1 Declararea claselor......................................................................................................................2
9.1.2 Definirea obiectelor.....................................................................................................................2
9.1.3 Care este diferenta dintre clase si obiecte?..................................................................................3
9.2 Incapsulare si metode de access..........................................................................................................3
9.2.1 Tipuri de access...........................................................................................................................3
9.2.2 Metode de acces la atributele claselor.........................................................................................4
9.3 Constructorii........................................................................................................................................5
9.3.1 Constructorul de copiere..............................................................................................................7
9.4 Destructorii..........................................................................................................................................7
9.5 Metode constante.................................................................................................................................8
9.6 Atribute constante................................................................................................................................9
9.7 Atribute statice...................................................................................................................................10
9.8 Metode statice...................................................................................................................................10
9.9 Metodele inline..................................................................................................................................11
9.10 Organizarea codului.........................................................................................................................11
9.10.1 Declaratii anticipate.................................................................................................................12
9.11 Functii friend...................................................................................................................................13
9.12 Pointerul this...................................................................................................................................14
9.13 Structuri de date si clase..................................................................................................................15
9.14 Sumar..............................................................................................................................................15
9.15 Intrebari si exercitii.........................................................................................................................16
9.16 Bibliografie......................................................................................................................................17

1
InfoAcademy Adonis Butufei

9 CLASE SI OBIECTE
In acest capitol vom discuta despre clase si obiecte, diferenta dintre o clasa si un obiect.
Vom invata primul mecanism al programarii obiectuale: incapsularea.
Vom organiza codul clasei in fisiere header si fisiere sursa.
Vom invata cum sa lucram cu obiectele.

9.1 Clase, membri si obiecte

Practic se pot scrie programe complexe folosind doar variabile numerice si siruri de caractere, insa efortul
de scriere, intelegere si mentenanta este foarte mare.
Inainte de aparitia programarii orientate pe obiecte functiile si datele erau separate. Se foloseau structuri
de date pentru crearea unor tipuri definite de utilizator, insa functiile care lucrau cu aceste structuri erau
separate.
In activitatile curente obiectele cu care interactionam au proprietati si multe dintre obiecte au si
comportament.
In programarea obiectuala nu ne gandim la structuri de date si la functiile care lucreaza cu aceste
structuri, ci ne gandim la modelarea obiectelor, ca si cum ar fi reprezentarea obiectelor din lumea reala cu
datele si comportamentul lor. De exemplu, cand ne gandim la un automobil, nu ne gandim la niste
specificatii si cum se poate lucra cu aceste specificatii. Ne gandim la un obiect care arata si actioneaza
intr-un mod precis.

Clasele permit combinarea datelor cu functiile care lucreaza cu aceste date. Elementele claselor, datele si
functiile se numesc membri. Pentru datele membru se foloseste termenul atribute si pentru functiile
membru se foloseste termenul metode.

9.1.1 Declararea claselor

Declararea claselor este similara cu declararea structurilor.
Exemplu:
class Complex
{
// metode si atribute ...
};

In acest exemplu este declarata o clasa de tip complex.

Important
Declararea unei clase se termina intotdeauna cu caracterul (;). Omiterea lui genereaza erori de compilare.

9.1.2 Definirea obiectelor

Dupa declararea unei clase o putem folosi pentru a declara variabile care au tipul acestei clase.
Exemplu:
Complex c1;

2
InfoAcademy Adonis Butufei

In acest exemplu c1 este un obiect de tip complex.

9.1.3 Care este diferenta dintre clase si obiecte?

Putem gandi o clasa ca fiind planul unei case iar obiectul ca fiind o casa reala cu pereti, usi etc, creat dupa
planul respectiv. Clasa este un tip de date pe cand obiectul este o variabila de acel tip care are un domeniu
de viata. Obiectele se numesc si instante ale claselor.

9.2 Incapsulare si metode de access

Mecanismul de incapsulare permite gruparea datelor si metodelor. Acest mecanism ascunde detaliile de
implementare ale unui obiect oferind un set de functii prin care pot interactiona cu acel obiect.

Pentru accesul membrilor se foloseste operatorul punct (.) ca si la structuri.

Exemplu:
Complex c1;
c1.re = 2.5;

9.2.1 Tipuri de access

Metodele si atributele claselor au trei tipuri de acces: public, protected si private. Pentru
specificarea tipului de acces se folosesc directive cu acelasi nume (public, protected si private).
Atunci cand nu este specificata nicio directiva, se foloseste implicit tipul de acces private.

Exemplu:
class TipuriDeAccess
{
// membri privati

public:
// membri publici

protected:
// membri protected

private:
// membri privati
};

Aceasta clasa prezinta toate tipurile de acces.

Important

3
InfoAcademy Adonis Butufei

• Directivele de acces definesc zone in declararea clasei. O zona incepe pe linia in care se afla directiva
si se termina pe linia in care apare o noua directiva sau pe linia unde se termina declararea clasei.

• Toti membrii declarati intr-o zona au tipul de acces al zonei respective.

• Putem avea mai multe zone cu acelasi tip de acces in declararea unei clase.

Membrii cu tipul de acces public pot fi apelati din afara clasei. Cei cu tipul de acces private pot fi apelati
doar din metodele clasei, iar tipul protected doar din metodele clasei sau claselor derivate1.

Exemplu:
class Complex
{
double _re;
double _im;
};

In acest exemplu este prezentata clasa Complex care are doua atribute private.
Nota
Pentru a diferentia atributele clasei de variabilele locale sau parametri am folosit prefixul (_).
O incercare de acces a acestor atribute in afara clasei genereaza eroare de compilare.
Exemplu:
Complex c1;
c1._re = 1.5; // genereaza eroare

9.2.2 Metode de acces la atributele claselor

Este recomandabil ca atributele sa fie private sau protected pentru a preveni accesul neautorizat.
Pentru a accesa din exterior atributele se pot folosi metode de acces.
Exemplu:
1: class Complex 11: void Im(double val);
2: { 12: };
3: double _re; 13:
4: double _im;
5:
6: public:
7: double Re();
8: void Re(double val);
9:
10: double Im();

1 Clasele derivate si mostenirea vor fi tratate intr-un capitol viitor.

4
InfoAcademy Adonis Butufei

14: double Complex::Re() 27: void Complex::Im(double val)

15: { 28: {
16: return _re; 29: _im = val;
17: } 30: }
18: 31: int main()
19: double Complex::Im() 32: {
20: { 33: Complex c1;
21: return _im; 34: c1.Re(2.0);
22: } 35: c1.Im(3.5);
23: void Complex::Re(double val) 36: return 0;
24: { 37: }
25: _re = val;
26: }

Codul acestui exemplu a fost prezentat pe doua coloane pentru economie de spatiu.
Clasa complex are o pereche de metode pentru fiecare atribut: cate o metoda care returneaza valoarea
curenta2 si o metoda care modifica valoarea curenta a atributului3.
Dupa declararea clasei urmeaza definirea metodelor. Observam si aici operatorul rezolutie (::) pe care
l-am intalnit si in capitolul 8 la spatii de nume pe care il folosim in acelasi mod pentru a specifica
apartenenta metodelor la clasa.

9.3 Constructorii
Variabilele simple pot fi initializate folosind operatorul =. Initializarea asigura faptul ca variabila va avea
intotdeauna o valoare determinata. Pentru initializarea atributelor unei clase se folosesc metodele
constructor care au acelasi nume ca si clasa. Constructorii nu au nici un tip de returnat. In momentul
declararii unui obiect, compilatorul apeleaza constructorul clasei care initializeaza atributele.

Putem adauga la clasa Complex4 prezentata anterior un constructor fara parametri care initializeaza
ambele atribute cu 0. Constructorul fara parametri al unei clase se numeste constructor implicit.
class Complex Complex::Complex()
{ {
public: _re = 0.0;
Complex(); _im = 0.0;
}; }

In momentul declararii unei variabile de tip complex este apelat acest constructor.
Exemplu:
#include <iostream>
using namespace std;

2 Aceasta metoda se numeste getter.

3 Aceasta metoda se numeste setter.
4 Pentru simplitate in exemplele din acest capitol vom prezenta numai modificarile aduse clasei complex.
5
InfoAcademy Adonis Butufei

int main()
{
Complex c; // este apelat constructorul
cout << c.Re() << " + " << c.Im() << "i\n";
return 0;
}

La rularea acestui program pe ecan va apare mesajul 0 + 0i.

Exista cazuri frecvente cand dorim sa intializam obiectele unei clase in moduri diferite. De exemplu
pentru clasa complex ar fi util daca am putea initializa ambele atribute in momentul definirii variabilei.
Pentru aceasta vom folosi supraincarcarea constructorului cu parametrii necesari.
Exemplu:
class Complex Complex::Complex(double re,
double im)
{
{
public:
_re = re;
Complex(double re, double im);
_im = im;
};
}

Deoarece am folosit prefixul (_) diferentierea parametrilor de atributele clasei este evidenta.
Folosind acest constructor putem initializa un obiect de tip complex cu valorile dorite intr-o singura linie
de cod.
Exemplu:
1: int main()
2: {
3: Complex c(2.5, 3.4);
4: return 0;
5: }

In acest exemplu in linia 3 este apelat al doilea constructor care initializeaza atributele _re si _im cu
valorile 2.5 respectiv 3.4.

Important
In standardul C++ curent un constructor nu poate apela alt constructor al aceleiasi clase. Urmatorul cod
genereaza erori de compilare.
Complex::Complex() : Complex(0.0, 0.0)
{
}

Atunci cand avem o sectiune de cod duplicata in constructorii clasei se poate muta acea sectiune intr-o
functie privata care poate fi apelata din fiecare constructor.

Exemplu:
6
InfoAcademy Adonis Butufei

In cazul clasei Complex codul pentru initializarea atributelor este similar in ambii constructori.
Declaram metoda Init in sectiunea privata cu urmatorul prototip:
void Init(double re = 0.0, double im = 0.0);

Folosim 0.0 valoare implicita pentru ambii parametri. Implementarea este foarte simpla, practic se
copiaza codul din al doilea constructor. Deoarece am specificat valorile implicite in prototipul functiei nu
mai este necesar sa le scriem si la implementare.

7
InfoAcademy Adonis Butufei

void Complex::Init(double re, double im)

{
_re = re;
_im = im;
}

Actualizam constructorii:
Complex::Complex()
{
Init();
}
Complex::Complex(double re, double im)
{
Init(re,im);
}

Folosind aceasta strategie am eliminat duplicarea codului.

9.3.1 Constructorul de copiere

Constructorul de copiere permite crearea unor instante cu valori identice pentru atribute. El are ca
parametru o referinta constanta de tipul clasei.
In exemplul de mai jos este prezentat prototipul constructorului de copiere pentru clasa Complex.
Complex(const Complex& src);

Mai jos este prezentata implementarea constructorului de copiere. Initializam noua clasa cu valorile
atributelor _re si _im din clasa sursa.
Complex::Complex(const Complex &src)
{
Init(src._re, src._im);
}

Constructorul de copiere este apelat explicit atunci cand folosim un obiect sau implicit atunci cand
apelam o functie care foloseste transferul prin valoare pentru parametri, ca in exemplul de mai jos:
Complex c1(2.5, 3.7);
Complex c2(c1); // apel explicit al constructorului de copiere.
Complex c3 = c1; // apel implicit al constructorului de copiere.
Complex c4 = Add(c1, c2); // Unde Add are prototipul:
// Complex Add(Complex c1, Complex c2) (transfer prin valoare);

Pentru evitarea copierii obiectelor, functiile si metodele folosesc transferul prin referinta sau prin adresa
pentru parametrii care sunt obiecte.

9.4 Destructorii
Destructorii sunt apelati de compilator in momentul cand un obiect a ajuns la sfarsitul domeniului de
8
InfoAcademy Adonis Butufei

viata, in scopul eliberarii resurselor folosite de clasa (eliberarea memoriei, inchiderea unui fisier etc). O
clasa poate avea mai multi constructori insa un singur destructor.
Caracteristicile destructorului:
• Numele destructorului foloseste prefixul (~) urmat de numele clasei.
• Destructorul nu are parametri.
• Destructorul nu are tip de returnare.

Exemplu:
class Complex Complex::~Complex()
{ {
}
public:
~Complex();
};

9.5 Metode constante

In capitolele anterioare am folosit const pentru a declara variabile a caror valoare nu se poate schimba. O
metoda constanta este o metoda care nu modifica atributele clasei si nu apeleaza alte metode care nu sunt
constante.
Pentru a declara o metoda constanta folosim cuvantul cheie const dupa inchiderea parantezelor
prototipului.
Exemplu:
class Complex
{
public:
double Re() const;
double Im() const;
};

Implementarea acestor functii este:

double Complex::Re()const double Complex::Im()const
{ {
return _re; return _im;
} }

Modificarile valorilor atributelor in metodele declarate constante genereaza erori de compilare.

9
InfoAcademy Adonis Butufei

9.6 Atribute constante

Sa presupunem ca avem urmatoarea clasa care are un atribut constant.
class Buffer
{
const int _size;
public:
Buffer ();
};

Initializarea acestui atribut nu se poate face in declararea clasei ca in exemplul de mai jos.
class Buffer
{
const int _SIZE = 1024; // Genereaza eroare de compilare5.
//....
};

De asemenea setarea valorii in constructor genereaza eroare de compilare.

Buffer::Buffer()
{
_SIZE = 1024; // Genereaza eroare de compilare.
}

Pentru a putea initializa acest atribut trebuie sa folosim lista de initializare a constructorului. Aceasta lista
de initializare se executa inainte de executia constructorului. Aici compilatorul aloca memoria pentru
atributele clasei si acesta este momentul cand putem seta valorile atributelor constante. Sintaxa este
prezentata in exemplul urmator:
Buffer::Buffer () : _SIZE(1024)
{
}

Se folosesc doua puncte dupa paranteza ) constructorului apoi urmeaza atributele pe care dorim sa le
initializam, separate prin virgula. Lista de initializare se poate folosi si in cazul atributelor normale si
poate aduce o imbunatatire a performantei daca atributele se initializeaza in ordinea in care au fost
declarate.

In capitolul doi am intalnit tipurile de constante enumerate. Aceste constante sunt folosite frecvent in
cazul in care tipul constantei este intreg deoarece permite o initializare mai simpla. Putem modifica
exemplul anterior in modul urmator pentru a folosi constantele enumerate:
class Buffer
{
enum { _SIZE = 1000};
public:
//..

5 Standardul C++ versiunea 11 aceasta declarare nu genereaza eroare de compilare.

10
InfoAcademy Adonis Butufei

};

9.7 Atribute statice

Cum am putea numara toate instantele de tip complex prezente in memorie la un moment dat? O solutie
ar fi sa folosim o variabila globala pe post de contor. In constructor este incrementata si in destructor este
decrementata.
Aceasta modalitate nu functioneaza. Incapsularea nu mai este respectata deoarece folosim o variabila
globala care contine informatii despre starea instantelor clasei.

In C++ aceasta problema se poate rezolva foarte simplu folosind un atribut static in loc de o variabila
globala.

Exemplu:
Declaram un atribut static privat:
class Complex
{
private:
static int _nrInstante;
};

Definim atributul:
int Complex::_nrInstante = 0;

Apoi modificam constructorii si destructoul sa incrementeze si sa decrementeze aceasta variabila.

Atributele obisnuite apartin obiectelor insa atributele statice apartin clasei. Deoarece avem o singura
definitie a clasei exista o singura variabila care este actualizata de toate instantele.

9.8 Metode statice

Am vazut anterior ca atributele statice apartin clasei, nu instantelor acelei clase. Ar trebui sa existe un
mecanism care sa ne permita interactiunea cu aceste variabile fara a crea instante noi. In C++ pentru acest
scop se folosesc metodele statice.
Exemplu:
Declaram o metoda statica in sectiunea publica:
class Complex
{
public:
static int NrInstante();
};

Definim metoda:
int Complex::NrInstante()

11
InfoAcademy Adonis Butufei

{
return _nrInstante;
}

Deoarece aceasta metoda apartine clasei, nu instantelor, ea poate fi apelata folosind numele clasei:
cout << Complex::NrInstante() << "numere complexe sunt in memorie\n";

9.9 Metodele inline

Pentru a declara o metoda inline avem doua variante: folosim cuvantul cheie inline
inline double Complex::Re()
{
return _re;
}

sau scriem implementarea in fisierul header

class Complex
{
public:
double Re () { return _re; }
};

9.10 Organizarea codului

Ca si la functii codul claselor se poate organiza in fisierele sursa si fisierele header. In mod uzual fiecare
clasa are un fisier header si un fisier sursa. Ambele fisiere au numele clasei si extensiile corespunzatoare.
Exemplu:
Clasa Complex este declarata in fisierul Complex.h care are urmatorul continut:
#ifndef _COMPLEX_H_
#define _COMPLEX_H_
class Complex
{
double _re;
double _im;
public:
Complex(double re = 0.0, double im = 0.0);
Complex(const Complex& src);

double Re() const;

void Re(double val);

double Im() const;

void Im(double val);

12
InfoAcademy Adonis Butufei

};
#endif

si fisierul Complex.cpp care contine implementarea metodelor si are urmatorul continut:

#include <iostream>
#include "Complex.h"
using namespace std;

Complex::Complex(double re , double im ) :
_re(re), _im(im)
{
cout << "Complex::Complex(re,im)\n";
}

Complex::Complex(const Complex& src)

{
_re = src._re;
_im = src._im;
cout << "Complex::Complex(const Complex& src)\n";
}

double Complex::Re()const
{
return _re;
}

double Complex::Im()const
{
return _im;
}

void Complex::Re(double val)

{
_re = val;
}

void Complex::Im(double val)

{
_im = val;
}

13
InfoAcademy Adonis Butufei

9.10.1 Declaratii anticipate

Pentru a putea apela o functie este necesar ca una din urmatoarele conditii sa fie satisfacuta: prototipul
functiei este declarat in cod inainte de apel sau functia este definita in cod inainte de apel.

Pentru a folosi un tip de data definit de utilizator (clasa, structura, uniune etc) trebuie ca acest tip sa fie
declarat anterior in cod. Deoarece tipurile de date se declara in fisierele header, pentru reducerea
dependintelor de include si izolarea detaliilor de implementare se folosesc declaratiile anticipate. Aceste
declaratii elimina necesitatea includerii fisierului header in care au fost declarate in alte headere atunci
cand se folosesc date sau parametri de tip referinta sau pointer la aceste tipuri. Headerul se va include in
fisierul sursa care acceseaza atributele sau metodele acelui tip.
De exemplu, daca in fisierul a.h avem urmatorul prototip de functie:
//a.h
void PrintPersoana(Persoana &persoana);

Iar Persoana este o clasa putem adauga urmatoarea declaratie anticipata:

// a.h
class Persoana; // declaratie anticipata pentru clasa Persoana
void PrintPersoana(Persoana &persoana);

In fisierul a.cpp trebuie inclus headerul persoana.h pentru a putea implementa functia
PrintPersoana.

9.11 Functii friend

Functiile friend pot accesa membrii (atribute si metode) protected si private ale obiectelor. Exista cazuri
cand este necesar accesul la acesti membri din afara obiectului. Pentru a putea realiza acest lucru se
declara o functie friend in clasa. Sintaxa pentru declararea unei functii friend este:
class Exemplu
{
//...
friend tipReturn NumeFunctieFriend(lista parametri);
};

Important
Deoarece NumeFunctieFriend este o functie nu metoda (deci nu apartine clasei) ea se defineste in modul
urmator:
tipReturn NumeFunctieFriend(lista parametri)
{
//...
}

Functia se declara oriunde in interiorul clasei, deoarece este functie externa clasei si nu este influentata de
nivelurile de acces ale clasei.
Mai jos este prezentata declararea functiei friend Print pentru clasa Complex:
1: class Complex
2: {

14
InfoAcademy Adonis Butufei

3: double _re, _im;

4: public:
5: Complex(double re, double im) : _re(re), _im(im) {}
6: friend void Print(const Complex &src);
7: };

Definirea acestei functii este:

1: void Print(const Complex &src)
2: {
3: cout << src._re << " " << src._im;
4: }

Important:
Functiile friend se folosesc doar in cazuri cand alte solutii nu pot fi aplicate deoarece elimina incapsularea
oferita de programarea obiectuala6.

9.12 Pointerul this

Este un pointer special care contine adresa obiectului curent si poate fi accesat doar din metodele clasei
care nu sunt statice. Practic acest pointer este transmis ca parametru ascuns pentru toate apelurile
metodelor.
Este folosit explicit pentru a permite apelul succesiv a doua metode care returneaza referinta la obiectul
curent. Dupa ce se executa prima metoda rezultatul returnat este obiectul curent si se poate apela o alta
metoda a obiectului. Acest mod de apel se numeste apelul in cascada. De exemplu pentru clasa complex
putem modifica metodele de setare pentru partea reala si partea imaginara ca sa permita apelul in cascada
in exemplul urmator:
class Complex Complex& Complex::Re(double re)
{ {
public: _re = re;
//... return *this;
Complex& Re(double re); }
Complex& Im(double im);
}; Complex& Complex::Im(double im)
{
_im = im;
return *this;
}

Din definitia metodelor observam ca dupa setarea valorii atributului se returneaza o referinta la obiectul
curent (instructiunea return *this;) Cu aceasta varianta a metodelor putem seta valorile ca in
exemplul de mai jos:
Complex c;
c.Re(2.5).Im(3.2); // apel in cascada echivalent cu:

6 Cum vom vedea in capitolul urmator functiile friend se folosesc pentru definirea operatorilor binari claselor.
15
InfoAcademy Adonis Butufei

// c.Re(2.5);
// c.Im(3.2);

16
InfoAcademy Adonis Butufei

9.13 Structuri de date si clase

Exista o asemanare foarte mare intre structurile de date si clase. In C++ singura diferenta dintre o
structura de date si clase este ca tipul de acces implicit este privat pentru clase si public pentru structuri de
date.
Putem defini metode pentru o structura de date in acelasi mod ca si pentru clase si, daca folosim
directivele de acces prezentate anterior, putem obtine aceeasi functionalitate.

9.14 Sumar
Clasele creaza noi tipuri de date prin gruparea datelor si functiilor care lucreaza cu aceste date.

Obiectele sunt variabile care au tipul definit de clase. Ca si analogie, clasa reprezinta planul unei case iar
obiectele sunt cladirile construite folosind acel plan.

Incapsularea permite ascunderea detaliilor de implementare, folosind directivele de acces, si ofera un set
de metode prin care putem interactiona cu obiectele.

Constructorii sunt metode speciale care sunt apelate de compilator in momentul crearii obiectelor pentru
initializarea datelor. Un constructor nu poate apela alt constructor.
Destructorii sunt metode speciale care sunt apelate de compilator in momentul in care domeniul de viata
al unui obiect s-a terminat, pentru eliberarea resurselor. O clasa poate avea un singur destructor.

Folosind metode de acces putem interactiona cu datele obiectelor.

Metodele constante nu modifica atributele obiectelor. Folosind directiva const pentru metode putem
identifica foarte usor erorile de modificare neautorizata a atributelor.

Atributele statice apartin claselor. Ele pot fi accesate de toate instantele acelei clase.
Metodele statice pot accesa doar atributele statice ale clasei si se pot apela fara a crea o instanta a acelei
clase.

Metodele inline se pot declara folosind cuvantul cheie sau scriind implementarea in fisierul header.

Declararea claselor se scrie in fisiere header si implementarea in fisiere sursa.

Structurile de date sunt echivalente cu clasele in C++. Singura diferenta este ca pentru clase tipul de acces
implicit este privat iar pentru structuri este public.

17
InfoAcademy Adonis Butufei

9.15 Intrebari si exercitii

1. Creati un proiect in Visual C++ si implementati clasa Complex prezentata in acest capitol.
2. Rulati fiecare exemplu prezentat in capitol.
3. Care este eroarea din exemplul de mai jos?
class Fractie
{
private:
int _numarator;
int _numitor;
public:
Fractie(int numarator, int numitor);
}

4. Dupa corectarea declaratiei clasei anterioare urmatorul cod genereaza erori de compilare. Care este
motivul?
Fractie f;

5. Declarati o clasa Persoana care are urmatoarele atribute private: _nume, _prenume, _varsta. Scrieti
metodele de acces (de setare si citire a acestor atribute).

6. Declarati si implementati constructorul de copiere pentru clasa Persoana.

7. Urmatorul cod genereaza erori de compilare. Care este motivul?

class Numar
{
int _val;
Numar(int val = 0);
};

Numar::Numar(int val)
{
_val = val;
}

int main()
{
Numar a(10);
}

8. Urmatorul cod genereaza erori de compilare. Care este eroarea?

class A

18
InfoAcademy Adonis Butufei

{
int _test;
public:
static int X();
};

int A::X()
{
return _test;
}

9. Scrieti implementarea constructorului care foloseste lista de initializare pentru urmatoarea clasa:
class Punct
{
double _x;
double _y;
double _z;
public:
Punct(double x = 0.0,double y = 0.0, double z = 0.0);
};

10. Urmatorul cod genereaza erori de compilare. Care este greseala?

class A
{
~A();
};

int main()
{
A a;
}

9.16 Bibliografie
• Teach yourself C++ In an Hour A day, Sixth Edition, Sams, Jesse Liberty, Cap 10.
• Practical C++ Programming, Second Edition, O'Reilly, Steve Oualline, Cap 13 - 14.
• C++ Without Fear, Second Edition, Prentice Hall, Brian Overland, Cap 11 - 12.

19