PROGRAMAREA ORIENTAT PE OBIECTE

NOTE

DE

CURS

REV. 01

Liviu erbnescu

UNIVERSITATEA HYPERION

CUPRINS

1. Iniiere ntr-un mediu de programare. Structura

unui program C++.
2. Noiunea de clas i obiect. Operatori specifici
C++.
3. Clase i moteniri. Clase de baz virtuale
4. Constructori i destructori
5. Modificatorii i specificatorii de acces
6. Date i funcii de tip friend i statice
7. Polimorfism, funcii virtuale
8. Suprancrcarea operatorilor
9. Fluxuri de intrare/ieire.Obiecte standard
10. Fluxuri de intrare/ieire.Operatii de
intrare/iesire cu fisiere
11. Tratarea excepiilor
12. Utilizarea claselor wxWidgets

INIIERE NTR-UN MEDIU DE PROGRAMARE.

STRUCTURA UNUI PROGRAM C++
Mediul integrat - OpenSource - CodeLite
Un spaiu de lucru (workspace) detine un numar de proiecte, de
exemplu, acestea pot avea legtur unele cualtele sau nu
Crearea unui spaiu de lucru se realizeaz prin selectarea "
"Workspace | Create new Workspace""
Un proiect (project) poate avea va rezultat n urma compilrii
i apoi a link-editrii un executabil, o bibliotec dinamic
(*.DLL), o bibliotec static(*.LIB), etc.
Proiectul n sine conine toate informaiile necesare pentru a
produce o aplicaie de un anumit tip (aplicaie consol,
aplicaie grafic ce utilizeaz un anumit set de controale
vizuale, aplicaie cu obiecte grafice, etc).
Fiierul ce conine informaii despre spaiul de lucru se
numete <workspace-name>.workspace
Fiierul ce conine informaii despre proiect este <projectname>. prj
Pentru crearea unui proiect nou se va utiliza opiunea GUI
(Graphics User Interface).

Structura unui program C++

Un programC++ cuprinde urmtoarele elemente pricipale:

operatori (aritmetici, logici, etc)

instruciuni (de decizie, de parcurgere a unei bucle,

etc)

funcii (apelate din cadrul bibliotecilor sau definite de

utilizator)

variabile i constante

funcia main()

Textul unui program poate fi scris ntr-un fiier sau n

mai multe fiiere. Un program va avea o singur funcie main()
indiferent dac este scris ntr-un singur fisier sau n mai
multe fiiere. Programul compilat i linkeditat va incepe
ntodeauna prin lansarea n execuie a instruciunilor i
funciilor din cadrul lui main(). Prin ieirea din funcia
main() se ncheie i execuia programului.
3

NOIUNEA DE CLAS I OBIECT.

OPERATORI SPECIFICI C++
CONCEPTE FUNDAMENTALE
Ideea de baza de la care pleaca programarea orientata obiect
este de a grupa structurile de date cu operatiile care
prelucreaza respectivele date. Un asemenea ansamblu poarta
denumirea de obiect sau clasa (tipul datei). Proiectarea de
programe utilizand clase se numeste programare orientat pe
obiecte (OOP- Object Oriented Programming).
Notiuni fundamentale:
Datele (membrii) i funciile (membrele / metodele) unei
clase
Datele sunt reprezentate prin declaraiile variabilelor din
cadrul clasei. n cadrul unei clase pot fi declarate inclusiv
variabile de tip structur sau de tip clas.
Date + Metode = Obiect sau Clas (tipul datei)
Principiul ncapsulrii (ascunderea informaiei ce st la
baza realizrii clasei):
accesul la datele membre se poate
face numai prin intermediul setului de metode asociat.
Obiectul este caracterizat complet prin metodele asociate. O
parte din metode vor fi utilizate de cel ce utilizeaz clasa
n cadrul aplicaiilor, iar alt parte va fi invizibil pentru
utlizatorul final (att codul ct i apelul acestora). Conform
principiului ncapsulrii utilizatorul nu are acces la date ci
numai la metodele pe care dezvoltatorul clasei le-a lsat
pentru a putea fi apelate.

Operatorii specifici C++

OPERATORUL

SIMBOLUL

FORMA

rezoluie
/
indicator
acces

::

::a
::f()

valoare
valoare

.*
->*

OB.*a
OB->*a

new

new

new tip

delete

delete

delete a
delete
a[]

this

this/
*this

this

Operaia realizat

- acceseaz variabilele globale

chiar dac au acelai nume cu cele
locale
- acceseaz membrii/membrele
claselor
- ntoarce valoarea (OB valoare)
- ntoarce valoarea (OB pointer)
aloc memorie. ex ptr. un vector de
10 ntregi: new int[10], ntoarce
NULL n caz de eec altfel ntoarce
adresa alocat
elibereaz zona de memorie
arat adresa obiectului curent (n
care ne aflm) iar *this este
valoarea obiectului curent

CLASE I MOTENIRI. CLASE DE BAZ VIRTUALE

Procedeul de derivare permite definirea unei clase noi, numit
clas derivat, care motenete propietile (membri + membre)
unei clase deja definite, numit clas de baz, pe care le
completeaz cu propieti (membri+membre) noi. Clasa de baz
nu este afectat i nu trebuie recompilat, declaraia
(fiierul header) i codul obiect (fiier obj / dll/ lib) ale
clasei de baz sunt suficiente pentru crearea unei clase
derivate.
Dintr-o clas (numit clas de baz) pot fi derivate mai multe
clase, iar fiecare clas derivat poate servi ca baz pentru
alte clase derivate. Astfel se realizeaz o ierarhie de clase.
Pornind de la clase simple i generale, fiecare nivel al
ierarhiei
acumuleaz
caracteristicile
(membri
+membre)
claselor "printe" (baz) i le adaug un anumit grad de
specializare.
n
cazul
n
care
o
clas
motenete
proprietile mai multor clase avem motenire multipl.
Sintaxa declaraia clasei derivate n cazul unei singure clase
de baz:
class nume_clasa_derivata : modificator_acces
nume_clas_baza iar n cazul mai multor clase de baz
(motenire
multipl):
class
nume_clasa_derivata
:
modificator_acces
nume_clas_baza_1
[<,
modificator_acces
nume_clas_baza_n >]
5

Funciile constructor, destructor i mecanismul de motenire

Clasa de baz, clasa derivat, sau ambele, pot avea funcii
constructor i/sau destructor. Cnd o clas de baz i una
derivat conin att funcii constructor ct i destructor,
cele constructor sunt executate n ordinea derivrii iar
funciile destructor sunt executate n ordine invers. Adic
duncia constructor din clasa de baz este executat naintea
celei din clasa derivat iar destructorul unei clase derivate
este executat naintea celui din clasa de baz. Cnd se
expliciteaz costructorul din clasa derivat trebuie s se
specifice care din constructorii clasei de baz este apelat
( constructorii difer ntre ei - n momentul declarrii prin numrul i tipul argumentelor) De asemenea, primele
argumente din constructorul clasei derivate trebuie s
coincid cu argumentele constructorului ales din clasa de
baz.
Sintaxa este:
nume_clas_derivat::nume_clas_derivat(lista_argumente_1,lis
ta_argumente_2):nume_clasa_baza (lista_argumente_1v) { corpul
constructorului }
unde: lista_agumente_1 este lista de argumente a
constructorului bazei (tipuri +variabile), lista_agumente_1v
este lista de argumente a constructorului bazei (variabile)
iar lista_agumente_2 este lista de argumente a suplimentar,
specific constructorului clasei derivate (tipuri +variabile)
iar n cazul motenirii multiple sintaxa este:
nume_clas_derivat::nume_clas_derivat (lista_argumente_1,
lista_argumente_2):nume_clasa_baza_1(lista_argumente_11v)[<,
nume_clasa_baza_n(lista_argumente_n1v) >] { corpul
constructorului }
unde lista_argumente_n1v sunt incluse n lista_argumente_1v
Clase de baz virtuale
Presupunem ca avem o clas BAZA i dou clase ce deriv din
BAZA, numite DER1 i DER2. Apoi din DER1 i DER2 derivm o
alt clas denumit DER12 . Deci, clasa DER12 motenete de
dou ori clasa BAZA, o dat prin DER1 i o dat prin DER2.
Acest lucru determin o ambiguitate cnd clasa DER12 vrea s
aib acces la datele din clasa BAZA. (de ex. pot fi date din
clasa BAZA, modificate n cadrul clasei DER1 sau modificate n
cadrul clasei DER2 - att DER1 ct i DER2 au cte o copie a
clasei BAZA). Pentru a rezolva aceast ambiguitate, C++
include un mecanism prin care doar o copie a clasei BAZA va fi
inclus n clasa DER12.
Acesta const n declararea clasei
6

BAZA ca fiind clasa de baz virtual. Se utilizeaz cuvntul

cheie virtual naintea modificatorului de acces.
(ex: class DER1: virtual public BAZA {};
class DER2: virtual public BAZA {};
class DER12: public DER1, public DER2 {};
#include <stdio.h>
#include <iostream>
//mostenire de tip - diamant
class A{
int a1,a2;
public:
A() {a1=0;a2=0;}
A(int a1_,int a2_) {a1=a1_;a2=a2_;}
void afis() {std::cout<<"/n a1="<<a1<<" a2="<<a2;}
};
class B: public virtual A
{int b1,b2;
public:
B():A() {b1=0;b2=0;}
B(int a1_,int b1_):A(a1_,0) {b1=b1_; b2=0;}
void afis1() {std::cout<<"/n b1="<<b1<<" b2="<<b2;}
};
class C: virtual public A
{int c1,c2;
public:
C():A() {c1=0;c2=0;}
C(int c1_,int c2_): A() {c1=c1_; c2=c1_;}
void afis1() {std::cout<<"/n c1="<<c1<<" c2="<<c2;}
};
class D: public B, public C
{ int d1,d2;
public:
D():B(),C() {d1=0;d2=0;}
};
int main(int argc, char **argv)
{
D x1;
x1.afis();
int m; std::cin>>m;//astapta o tasta
return 0;
}
// cuvantul cheie virtual permite eliminarea duplicatelor clasei A

CONSTRUCTORI I DESTRUCTORI

CONSTRUCTORI:
Constructorul se apeleaz automat la crearea fiecrui
obiect al clasei, creare de tip static, automatic sau
dinamic;
Funcia constructor are acelai nume cu al clasei (case
sensitive);
O clas poate avea mai muli constructuri, ei se deosebesc
prin numrul i tipul argumentelor;
In cazul n care nu se scrie nici un constructor se va
apela automat un constructor, fr argumente i de tip
public. Dac utilizatorul declar cel puin un constructor
atunci compilatorul nu mai genereaz acest constructor
implicit;
Exist i un constructor implicit de copiere ce
iniializeaz obiectul curent cu datele (membrii) din alt
obiect de acelai tip (aparinnd aceleiai clase) El are
forma nume_clas(nume_clasa &)i poate fi redefinit;
Constructorii nu ntorc valori;
Constructorii sunt apelai automat dup ce se se aloc
memorie (automatic sau static) pentru obiectele membru
(date membru /membrii)
DESTRUCTORI:
Destructorul este apelat automat cnd obiectul respectiv
i nceteaz existena n memorie.
Destructorul are acelai nume cu al clasei i se declar cu
operatorul ~ inainte;
Utilizatorul nu va putea apela explicit destructorul unei
clase;
Destructorul nu preia i nu ntoarce valori;
O clas are un singur destructor;
In cazul n care nu este declarat nici un destructor se va
apela unul implicit;
Destructorii sunt apelai automat naintea eliberrii
memoriei alocat automatic sau static pentru datele membru.
Explicitarea funciilor membre (inclusiv a constructorilor i
destructorilor) se poate face fie n interiorul declaraiei
clasei, fie n exteriorul clasei prin utilizarea operatorului
rezoluie " :: ".
Funciile din cadrul unei clase se pot clasifica n:
8

constructori;
destructori;
funcii normale de acces;
funcii de tip prieten (friend);
funcii virtuale;
funcii statice;
funcii de tipul operator.

Exemplu:
#include <stdio.h>
#include <iostream>
using namespace std;
class A3
{
public:
int a1;
protected: int a2;
private: int a3;
public:
A3(int a1_) { a1=a1_;a2=0;a3=0;//cout<<"\n constructor
A3(a1)<<a1:"<<a1;
}
A3(int a1_,int a2_,int a3_) {a1=a1_;a2=a2_;a3=a3_;}
void afis_a()
{cout<<"\nClass A3: a1="<<a1<<" a2="<<a2<<"
a3="<<a3;}
};
class B3:protected A3
{int b3; protected: int b2;
public: int b1;
B3(int a1_, int b1_):A3(a1_)

{b1=b1_;b2=0;b3=0;
//cout<<"\n constructor

B3(a1,b1)<<b1:"<<b1;
}
B3(int a1_,int a2_,int a3_,int b1_,int b2_,int
b3_):A3(a1_,a2_,112)
{b1=b1_;b2=b2_;b3=b3_;}
void afis_b()
{// cout<<"\nClass B3 a1="<<a3;
afis_a();
cout<<" b1="<<b1<<" b2="<<b2<<" b3="<<b3;}
};
int main(int argc, char **argv)
{
//A3 x(4);
//x.afis_a();
//B3 y(2,7);
9

//y.afis_b();
B3 z(1,2,3,4,5,6);
//z.afis_a();
z.afis_b();
getchar();
return 0;
}

Exemplu:
#include <stdio.h>
#include <iostream>
#include <string.h>
using namespace std;
class A{
protected:
char *sir;
unsigned long dim;
public:
A(unsigned long dim1);
A(char *);
void prel();
void afis();
~A();
};
A::A(unsigned long dim1)
{
dim=dim1;
if((sir=new char[dim])==NULL)
cout<<"Memorie insuficienta";
memset(sir,0,dim*sizeof(char));
}
A::A(char* sir1)
{
strcpy(sir,sir1); dim=strlen(sir);
}
A::~A()
{
if(sir) delete[] sir;
}
void A::prel()
{
//cin>>sir;
scanf("%s",this->sir);
}
void A::afis()
{
cout<<"\n Sirul este:"<<sir;
}

10

class A1:public A
{ char *sir_ord_cresc;
public:
A1(unsigned long dim1):A(dim1)
{ sir_ord_cresc = new char[dim];
}
A1(char * sir1):A(sir1) {sir_ord_cresc = new char[dim];}
bool cauta_caracter(char x)
{ for(int i=0;i<dim;i++)
if(sir[i]==x) return true;
return
false;
}
void ordoneaza_cresc()
{bool ordonat;int i;
strcpy(sir_ord_cresc,sir);
do{
for(i=1,ordonat=true;i<dim;i++)
if(sir_ord_cresc[i-1]>sir_ord_cresc[i])
{ sir_ord_cresc[i-1]=sir_ord_cresc[i1]^sir_ord_cresc[i];
sir_ord_cresc[i]=sir_ord_cresc[i-1]^sir_ord_cresc[i];
sir_ord_cresc[i-1]=sir_ord_cresc[i1]^sir_ord_cresc[i];
ordonat=false;
}
}while(!ordonat);
}
/*void afis()
{
cout<<"\n Sirul ordonat este:"<<sir_ord_cresc;
}*/
};
int main(int argc, char **argv)
{
A1 x(40);
x.prel();
//x.afis();
x.ordoneaza_cresc();
x.afis();
//getchar();
int m; cin>>m;
return 0;
}

11

MODIFICATORII I SPECIFICATORII DE ACCES

Datele (membrii) i membrele (funciile) din interiorul
unei clase pot avea urmtorii specificatori de acces:
- public: datele/membrele pot fi accesate de oriunde, chiar si
din afara clasei;
- protected: datele/membrele dintr-o clas de baz pot fi
vazute n interiorul claselor derivate dar nu i n afara
acestora;
- private: datele/membrele dintr-o clas nu sunt vzute dect
n interiorul clasei.
Implicit toate datele i metodele din cadrul unei clase sunt
private.
Daca constructorii nu ar fi declarai cu specificatorul de
acces public nu am putea avea obiecte de tipul clasei
respective n afara clasei.
Modificatorii de acces
Specificatorul
de acces din
clasa de baz

Modificator
de acces

private
protected
public
private
protected
public

private
private
private
public
public
public

Accesul
motenit de
clasa
derivat
inaccesibil
private
private
inaccesibil
protected
public

Accesul din
exterior
inaccesibil
inaccesibil
inaccesibil
inaccesibil
inaccesibil
accesibil

Exemplu
//main.h

class P_ABC
{

protected:
char *sir_c,tip;
long *sir_l;
double *sir_d;
short dim;
P_ABC(short dim1, char tip1); //'c' , 'l', 'd'
~P_ABC();
virtual void afisare()=0;

virtual void citire()=0; //functii virtuale pure ==> clasa de

baza virtuala ==> NU se pot instanta direct obiecte ale acestei
12

clase
};
class A : protected P_ABC
{
protected: //se pot apela in clasele derivate
char *sir;
public: //se pot apela in afara clasei si in afara ierarhiei de
clase
A(short dim1);
A(char*);
~A();
char* obtine_sir();
void afisare();
void citire();
};

class B : public P_ABC

{
protected:
long *sir;
public:
B(short dim1);
long* obtine_sir();
void afisare();
void setare(int i, long val) {sir[i]=val;}
void citire();
};
class Z
{ int x,y;
protected:
Z(int x1,int y1) {x=x1;y=y1;}
13

};
//mostenire multipla
class AZ: public A, protected Z
{ public:
AZ(short dim1,char valinit_c);
};
//main.cpp
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <main.h>
using namespace std;
P_ABC::P_ABC(short dim1,char tip1)
{
dim=dim1; sir_c=NULL;sir_d=NULL;sir_l=NULL; tip=tip1;
if(tip=='c') sir_c=new char[dim+1]; // +1 ptr. terminatorul de
sir '/0'
if(tip=='l') sir_l=new long[dim];
if(tip=='d') sir_d=new double[dim];
//
if(sir_c==NULL &&) {cout<<"Memorie insuficienta";return;}
}
P_ABC::~P_ABC()
{ if(sir_c) delete[] sir_c;
if(sir_l) delete[] sir_l;
if(sir_d) delete[] sir_d;
}
A::A(short dim1):P_ABC(dim1,'c')
{
//preia dimensiunea sirului
//dim=dim1;
//aloca memorie ptr. sir
// sir = new char[dim+1]; // +1 ptr. terminatorul de sir '/0'
// if(sir==NULL) {cout<<"Memorie insuficienta";return;}
// echivalent cu: if(!(sir= new char[dim])) {{cout<<"Memorie
insuficienta";return;}
sir=sir_c;
}
A::A(char* sir1):P_ABC(strlen(sir1),'c')
{ //dim=strlen(sir1);
//if(!(sir= new char[dim])) {cout<<"Memorie
insuficienta";return;}
sir=sir_c;
14

//strcpy(sir,sir1);
for(int i=0;i<dim;i++)

sir[i]=sir1[i];

}
A::~A()
{ //if(sir) delete[] sir;
}
char* A::obtine_sir() {return sir;}
void A::afisare()
{cout<<"\n Sirul din clasa A este:"<<sir;}
void A::citire()
{ cin>>sir;}
B::B(short dim1):P_ABC(dim1,'l')
{sir=sir_l;}
long* B::obtine_sir() {return sir;}
void B::afisare()
{cout<<"\n Sirul din clasa B este:"<<sir[0];}
void B::citire()
{ cin>>sir[0];}
/*AB::AB(char valinit_c, long valinit_l):A(5),B(9)
{
for(int i=0;i<dim;i++)
}*/
AZ::AZ(short dim1,char valinit_c):A(dim1),Z(2,3)
{ for(int i=0;i<dim;i++) sir[i]=valinit_c;
}

int main(int argc, char **argv)

{ A *s2,s1("abcd");
B *s3;
//P_ABC d(4,'c'); eroare : clasa de baza abstracta -- nu se vor
instantia obiecte
s2=new A("1234");
s1.afisare();
s2->afisare();
s3=new B(2);
//s3->citire();
15

s3->setare(0,45);
s3->afisare();
AZ t(5,'k');
t.afisare();
int m; cin>>m; //asteapta o tasta
return 0;
}

Funcii de tipul "prieten" (friend)

O funcie de tip friend (prieten) este o funcie care nu este
membr a clasei i are acces la toi membrii clasei. n
interiorul clasei, ea se declar prin scrierea cuvntului
cheie friend naintea declararaiei propiu-zise a funciei. O
clas ale crei funcii sunt, n totalitate, friend pentru
alt clas se numese clas prieten a acelei clase.
O funcie prieten, este o funcie declarat n afara clasei
(nu aparine clasei) i creia i se d acces la toate datele
din cadrul clasei. n interiorul clasei este declarat cu
cuvntul cheie friend n fa.
Adresa obiectului curent este dat de operatorul this.
MEMBRII STATICI
Un tip aparte de membri ai unei clase sunt membrii statici.
Atat functiile membru cat si datele membru (atributele) unei
clase pot fi declarate static.
Variabile
Membru
Statice
Daca declaratia unei variabile membru este precedata de
cuvantul-cheie static, atunci va exista o copie unica a acelei
variabile care va fi folosita in comun de catre toate
obiectele instantiate din clasa respectiva. Spre deosebire de
variabilele membru obisnuite, pentru variabilele statice nu
sunt create copii individuale ale acestora pentru fiecare
obiect in parte. Accesarea unei variabile statice se face
folosind numele clasei si operatorul de specificare a
domeniului ("::").
Cand se declar o data membru ca fiind static intr-o clasa, ea
nu este nca alocat. Prin declarare nu se aloca memorie,
acest lucru se realizeaz n exteriorul clasei. Pentru a
defini o variabila membru statica, aceasta trebuie prevazuta
cu o definire globala undeva in afara clasei. Variabilele
statice (ca si functiile membru statice de altfel) pot fi
utilizate indiferent daca exista sau nu instante ale clasei
respective. De aceea, initializarea unei variabile statice NU
poate cadea in sarcina constructorilor clasei (constructorii,
16

se stie, se executa doar la momentul generarii unei instante).

Constructorii pot, insa, sa modifice valorile variabilelor
statice (de exemplu, pentru a contoriza numarul instantelor
unei clase, create la executia unui program).
Variabilele membru statice sunt folosite cel mai adesea pentru
a asigura controlul accesului la o resursa comuna (ex.
scrierea
intr-un
fisier).
Acest tip de variabile se mai folosesc si pentru a stoca
informatii comune unei intregi clase de obiecte.
Functii Membru Statice
Si functiile membru pot fi declarate ca statice. In C++ o
functie membru statica se comporta asemanator cu o functie
globala al carei domeniu este delimitat de clasa in care este
definita.
Operatorul "this"
Cuvntul cheie this arat adresa obiectului curent (n care ne
aflm) iar *this este valoarea obiectului curent.
//functii friend
#include <stdio.h>
#include <iostream>
class A
{int a1;
friend void aduna(A& x1, A& x2);
public:
A() {a1=0;}
A(int a1_) {a1=a1_;}
};
void aduna(A& x1, A& x2)
{ int rez;
rez=x1.a1 +x2.a1;
std::cout<<"\n x1.a1+x2.a1="<<rez;
}
int main(int argc, char **argv)
{
A s(3),t(5);
aduna(s,t);
int m; std::cin>>m;
return 0;
}
//variabile de tip static
#include <stdio.h>
#include <iostream>
// definim variabila cnt pentru a contoriza numarul de obiecte de
tip A existente
class A
{ int a1;
public:
static int cnt;
17

A() {a1=0; cnt++;}

A(int a1_) {a1=a1_;cnt++;}
~A() {cnt--;}
static void afis() {std::cout<<"\n nr.obiecte:"<<cnt;}
};
int A::cnt=0; //aici se declara cnt -- variabila nu se afla in
obiectele instantiate
int main()
{
A x[10];//vector cu 10 obiecte de tip A, instantiate cu
constructorul implicit ()
{ A y[5], z(4);
std::cout<<"\n1:"; A::afis();
}
std::cout<<"\n2:"; A::afis();
int m; std::cin>>m;
return 0;
}

18

POLIMORFISM, FUNCII VIRTUALE

Funciile
virtuale
sunt
folosite
pentru
implementarea
obiectelor
polimorfice.
Obiectele
polimorfice
se
careacterizeaz prin faptul c folosind aceeai form de apel
pentru funciile membre realizm operaii diferite. Funciile
viruale implementeaz filozofia "o singur interfa, mai
multe metode", care pune n eviden "poli morfism-ul"
Variabile de tip pointer care puncteaz la clasele derivate
Presupunem dou clase, denumite:BAZA i DERIVATA, unde clasa
DERIVATA motenete clasa BAZA. n aceste condiii,
urmtoarele instruciuni sunt valabile:
BAZA *p; // pointer-ul care puncteaz la clasa baza
BAZA OB_TIP_BAZA; //un obiect de tip BAZA
DERIVATA OB_TIP_DER; // un obiect de tip DERIVATA
// pointer-ul p poate puncta (prelua adresa) la obiecte de tip
BAZA
p=&OB_TIP_BAZA; // p preia adresa lui OB_TIP_BAZA
// p poate puncta la obiecte derivate
p=&OB_TIP_DER; // p preia adresa lui OB_TIP_DER
Un pointer al clasei de baz poate puncta la un obiect din
clasa derivat, fr a genera vreo eroare, invers nu este
valabil. Prin acest pointer putem avea acces doar la membrii
clasei derivate care au fost motenii de la clasa de baz.
Funcii virtuale
O funcie virtual este o funcie membr a unei clase, care se
declar n interiorul unei clase de baz i se redefinete
(modific) n clasele derivate. Pentru a crea o funcie
virtual, trebuie s utilizm cuvntul cheie virtual, nainte
de declaraia funciei. La nivelul fiecrei clase funciile
virtuale mplementeaz cod specific clasei respective, ns
ele au acelai nume, aceeai list de parametrii i ntorc
aceelai tip de dat. Cnd un pointer al clasei de baz
puncteaz la o funcie virtual din clasa derivat, i aceasta
este apelat prin intermediul acestui pointer, compilatorul
determin care versiune (care din codurile/ care explicitare)
a funciei trebuie apelat, innd cont de tipul obiectului
(care clas) la care puncteaz acel pointer. Adic tipul
obiectului (clasa ) la care puncteaz determin versiunea
funciei virtuale care va fi executat.
19

O funcie virtual poate fi declarat i numai formal, ea

nerealiznd nimic concret, ea fiind declarat doar pentru ca
n clasele derivate s fie declarat i explicitat. O astfel
de funcie virtual, fr cod/explicitare se numete funcie
virtual pur. Sintaxa pentru o funcie virtual pur este:
virtual tip nume_funcie(list_de_parametri)=0;
O clas ce conine o funcie virtual pur se numete clas
abstract. Clasele abstracte sunt utilizate doar pentru a fi
motenite. Nu se pot intania obiecte pentru clase abstracte.
//polimorfism
#include <stdio.h>
#include <iostream>
using namespace std;
class Patrulater {
protected:
double laturi[4];
public:
Patrulater(double l1=0.0, double l2=0.0, double l3=0.0, double
l4=0.0)
{laturi[0] = l1; laturi[1] = l2; laturi[2] = l3;
laturi[3] = l4; }
virtual double perimetru() { return laturi[0]+
laturi[1]+laturi[2]+laturi[3]; }
virtual double arie() {};
};
class Dreptunghi : public Patrulater {
public:
Dreptunghi(double l1=0.0, double l2=0.0) : Patrulater(l1,l2,l1,l2)
{}
double perimetru() { return 2*(laturi[0]+laturi[1]); }
double arie() { return laturi[0]* laturi[1]; }
};
class Patrat : public Patrulater {
public:
Patrat(double l1 = 0.0) : Patrulater(l1,l1,l1,l1) {}
double perimetru() { return 4*laturi[0]; }
double arie() { return laturi[0]*laturi[0]; }
};
// *colectie[] === **colectie, prima scriere este sugestiva ptr.
vector de pointeri
void CalculeazaPerimetre(Patrulater *colectie[])
{// for-ul se executa atata timp cat elem != NULL
// elem este un pointer de parcurgere de tip Patrulater
// la fiecare iteratie se trece la adresa urmatoare
20

for(Patrulater *elem = *colectie; elem ; elem = *(++colectie))

printf("\n %f", (*elem).perimetru());
// sau printf("\n %f", elem->perimetru());
}
//se procedeaza idem si pentru arie
void afis_si_calc_perim(Patrulater *figuri_geom[])
{
for(int i=0;figuri_geom[i]!=NULL;i++)
{ double perim;
perim = figuri_geom[i]->perimetru();
cout<<"\n "<<perim;
}
}

int main(int argc, char **argv)

{
Patrulater *colectiePatrulatere[10];//vector cu 10 adrese la
obiecte de tip Patrulater
int i = 0;
colectiePatrulatere[i++] = new Patrat(6.5);
colectiePatrulatere[i++] = new Dreptunghi(6.0,7.5);
colectiePatrulatere[i++] = new Patrulater(2.0,3,1,5.2);
colectiePatrulatere[i++] = new Dreptunghi(2.0,1.4);
colectiePatrulatere[i++] = new Dreptunghi(2.0,7.3);
colectiePatrulatere[i++] = 0;
//CalculeazaPerimetre(colectiePatrulatere);
//sau
afis_si_calc_perim(colectiePatrulatere);
int m;cin>>m;
return 0;
}

21

SUPRANCRCAREA OPERATORILOR
Suprancrcarea operatorilor (overloading-ul) presupune
redefinirea operatorilor cu ajutorul funciei de tipul
operator.
Restricii privind suprancrcarea operatorilor:
- nu pot fi suprancrcai dect operatorii existeni;
- operatorii: " . "," .* "," :: " , " ?: " i " sizeof " nu
pot fi suprancrcai;
- operatorii binari vor fi suprancrcai doar ca operatori
binari;
- operatorii unari vor fi suprancrcai doar ca operatori
unari;
- se pstreaz precedena operatorilor operator (nu exista
posibilitatea de a determina, de exemplu, ca "+" sa fie
prioritar fata de "/");
Nu este posibila definirea unui operator care sa ia ca
parametri exclusiv pointeri (exceptand operatorii: = & ,).
- Nu se poate modifica numarul operanzilor preluati de un
operator (dar se poate ignora unul din parametri).
- Un operator trebuie ori sa fie membru al unei clase, ori sa
aiba cel putin un parametru de tip clasa. De la aceasta regula
fac exceptie doar operatorii new si delete;
- pentru operatorii : " = "," [] ", " () "," -> " funcia
operator trebuie s fie membr nestatic a clasei.
a)Pentru operatorul binar "op" avem: ( op poate fi unul din
operatorii din lista cu operatori C++)
Funcia
membr a
clasei
nemembr

Sintaxa formei de
apel externe
obiect1 op obiect2
obiect1 op obiect2

Sintaxa formei interne

(canonice) de apel
obiect1.operator op (obiect
2)
operator op (obiect1,
obiect2)

b)Pentru operatorul unar "op" avem:

Funcia
membr a
clasei
nemembr

Sintaxa formei de
apel externe
op obiect1
obiect1 op
op obiect1
obiect1 op

Sintaxa formei interne

(canonice) de apel
obiect1.operator op ()
obiect1.operator op ()
operator op (obiect1)
operator op (obiect1)

22

#include <stdio.h>
#include <iostream>
//supaincarcarea operatorilor
class VECT {
double v[3];
public:
//constructor declarat i explicitat n interiorul declaraiei
clasei
VECT()
{ v[0]=0; v[1]=0; v[2]=0;}
~VECT(){}//desctructor
//declaraie constructor cu 3 argumente
VECT(double x1,double x2,double x3);
//VECT(VECT&);//constructor de copiere
//operatorul atribuire
VECT operator=(VECT);
//ADUNAREA
C=A+B
friend VECT operator+(VECT,VECT); //C=operator+(A,B); --- C=A+B
VECT operator^(VECT); //C=B.operator^(A); --- C=B+A ( B --- this)
//ADUNAREA A+=B
VECT operator +=(VECT);
//void operator *=(VECT);
friend VECT operator ^=(VECT&,VECT&);
//friend void operator |=(VECT&,VECT&);
//X=-X
VECT operator-();
//sau
friend VECT operator!(VECT);
//double& operator[](int);
//friend bool operator==(VECT,VECT);
void afiseaza();
};
// explicitare constructor
VECT::VECT(double x,double y, double z)
{ v[0]=x;v[1]=y;v[2]=z; }
//explicitare constructor copiere
//VECT::VECT(VECT &w)
//{ v[0]=w.v[0]; v[1]=w.v[1]; v[2]=w.v[2];}
void VECT::afiseaza()
{ printf("\n Valorile: v[0]=%f,\n v[1]=%f,\n v[2]=
23

%f",v[0],v[1],v[2]);
}
//operatoru de atribuire X = Y
VECT VECT::operator=(VECT w)
{ v[0]=w.v[0];v[1]=w.v[1];v[2]=w.v[2];
return *this;
}
// X = W1 + W2 , operator + este funcie extern clasei
VECT operator+(VECT w1,VECT w2)
{ VECT elem;
elem.v[0]=w1.v[0]+w2.v[0];
elem.v[1]=w1.v[1]+w2.v[1];
elem.v[2]=w1.v[2]+ w2.v[2];
return elem;
}
// X = W1 ^ W2 , operator ^ este membr a clasei i o vom utiliza,
DE
//EXEMPLU pentru efectuarea ADUNAREA (adica de fapt X=W1+W2)
//unde W1 este obiectul curent (*this)
VECT VECT::operator^(VECT w) // w=W2
{
VECT elem;
elem.v[0]=v[0] + w.v[0];
elem.v[1]=v[1] + w.v[1];
elem.v[2]=v[2] + w.v[2];
return elem;
}
//X+=Y
VECT VECT::operator+=(VECT w)
{ v[0]=v[0] + w.v[0];
v[1]=v[1] + w.v[1];
v[2]=v[2] + w.v[2];
return *this;
}
/*
void VECT::operator*=(VECT w)
{ v[0]=v[0] + w.v[0];
v[1]=v[1] + w.v[1];
v[2]=v[2] + w.v[2];
}*/
VECT operator^=(VECT &w1, VECT& w2)
{
w1.v[0]=w1.v[0]+w2.v[0];
w1.v[1]=w1.v[1]+w2.v[1];
w1.v[2]=w1.v[2]+ w2.v[2];
24

return w1;
}
/*
void operator|=(VECT &w1, VECT& w2)
{
w1.v[0]=w1.v[0]+w2.v[0];
w1.v[1]=w1.v[1]+w2.v[1];
w1.v[2]=w1.v[2]+ w2.v[2];
}*/

// X = -X
VECT VECT:: operator-()
{ VECT elem(-v[0],-v[1],-v[2]);
return elem;
}
VECT operator!(VECT u)
{ VECT elem(-u.v[0],-u.v[1],-u.v[2]);
return elem;
}
int main(int argc, char **argv)
{
//vf. atribuire
/*
VECT x(1,2,3),y;
y=x;
y.afiseaza();
*/
//vf adunare + si atribuire
//
VECT x(1,2,3),y(10,11,12),z;
// z=x+y;
//sau
// z=operator+(x,y);
// z.afiseaza();
//vf. adunare ^ si atribuire
VECT x(100,200,300),y(10,11,12),z;
//z=x^y;
//sau
//z=x.operator ^(y);
//z.afiseaza();
//vf operator unar //

/*VECT s(3,-6,9);
s=-s;
s.afiseaza();int m; std::cin>>m; return 0; */
/*VECT s(3,-6,9);
s=!s;
s.afiseaza(); int m; std::cin>>m; return 0; */
25

//

VECT x(1,2,3),y(10,11,12);
//x^=y;
//x|=y;
x+=y;
x.afiseaza();
y.afiseaza();
int m; std::cin>>m;return 0;

}
Exemplu:
#include <stdio.h>
#include <iostream>
//supaincarcarea operatorilor
class VECT {
double v[3];
public:
//constructor declarat i explicitat n interiorul declaraiei
clasei
VECT()
{ v[0]=0; v[1]=0; v[2]=0;}
~VECT(){}//desctructor
//declaraie constructor cu 3 argumente
VECT(double x1,double x2,double x3);
//VECT(VECT&);//constructor de copiere
//operatorul atribuire
VECT operator=(VECT);
//operator indexare
double& operator[](int);
//supraincarcarea operatorului "identic"
friend bool operator==(VECT,VECT);
bool operator<(VECT);//semnificatie schimbata in identic
bool operator<=(VECT&);//semnificatie schimbata in identic
void afiseaza();
};
// explicitare constructor
VECT::VECT(double x,double y, double z)
{ v[0]=x;v[1]=y;v[2]=z; }
//explicitare constructor copiere
//VECT::VECT(VECT &w)
//{ v[0]=w.v[0]; v[1]=w.v[1]; v[2]=w.v[2];}
void VECT::afiseaza()
{ printf("\n Valorile: v[0]=%f,\n v[1]=%f,\n v[2]=
%f",v[0],v[1],v[2]);
}
26

//operatoru de atribuire X = Y
VECT VECT::operator=(VECT w)
{ v[0]=w.v[0];v[1]=w.v[1];v[2]=w.v[2];
return *this;
}
bool VECT::operator<(VECT A)
{ if(v[0]==A.v[0] && v[1]==A.v[1] && v[2]==A.v[2])
este echivalent cu v[0]
return true;
return false;
}

//this.v[0]

bool VECT::operator<=(VECT& A)
{ if(v[0]==A.v[0] && v[1]==A.v[1] && v[2]==A.v[2])
return true;
return false;
}
bool operator==(VECT A, VECT B)
{if(A.v[0]==B.v[0] && A.v[1]==B.v[1] &&
return true;
return false;
}

A.v[2]==B.v[2])

double& VECT::operator[](int i)
{
return v[i];
}
int main(int argc, char **argv)
{
VECT x(10,11,12),y(10,11,12);
//
x.afiseaza();
bool b;
// b=operator==(x,y);
// b=x==y;
// b=x.operator<(y);
// b=x<y; //semnificate de identitate (==)
b=x<=y; //semnificate de identitate (==)
if(b) printf("identice"); else printf("diferite");
/* double s;
s=x[0];
printf("x[0]:%f",s);
*/
int m; std::cin>>m;return 0;
27

}
Exemplu:
#include <stdio.h>
#include <string.h>
#include <iostream>
//supaincarcarea operatorilor
class VECT {
double v[3];
public:
//constructor declarat i explicitat n interiorul declaraiei
clasei
VECT()
{ v[0]=0; v[1]=0; v[2]=0;}
~VECT(){}//desctructor
//declaraie constructor cu 3 argumente
VECT(double x1,double x2,double x3);
//VECT(VECT&);//constructor de copiere
//operatorul atribuire
VECT operator=(VECT);
//operator indexare
char* operator[](int);
void afiseaza();
};
// explicitare constructor
VECT::VECT(double x,double y, double z)
{ v[0]=x;v[1]=y;v[2]=z; }
//explicitare constructor copiere
//VECT::VECT(VECT &w)
//{ v[0]=w.v[0]; v[1]=w.v[1]; v[2]=w.v[2];}
void VECT::afiseaza()
{ printf("\n Valorile: v[0]=%f,\n v[1]=%f,\n v[2]=
%f",v[0],v[1],v[2]);
}
//operatorul de atribuire X = Y
VECT VECT::operator=(VECT w)
{ v[0]=w.v[0];v[1]=w.v[1];v[2]=w.v[2];
return *this;
}
char* VECT::operator[](int i)
{char* den;
den=new char[10];
28

switch(i)
{ case 1: strcpy(den,"luni");break;
case 2: strcpy(den, "marti");break;
case 4: strcpy(den,"joi");break;
default: strcpy(den,"zi inc.");
}
return den;
}
int main(int argc, char **argv)
{
VECT x(10,11,12),y(10,11,12);
//
x.afiseaza();
bool b;
char *zi;
zi=x[10];
printf("Denumirea:1:%s",zi);
int m; std::cin>>m;return 0;
}

29

FLUXURI DE INTRARE/IEIRE.
OBIECTE STANDARD

Stream-urile au in principal rolul de a abstractiza

operatiile de intrare- iesire. Ele ofera metode de
scriere si citire a datelor independente de dispozitivul
I/O si chiar independente de platforma. Stream-urile
incapsuleaza (ascund) problemele specifice dispozitivului
cu care se lucreaza, sub libraria standard iostream.
In C++ stream-urile au fost implementate utilizand
clase, dupa cum urmeaza:
clasa streambuf gestioneaza buffer-ele.
clasa ios este clasa de baza pentru clasele de
stream-uri de intrare si de iesire. Clasa ios are
ca variabila membru un obiect de tip streambuf.
clasele istream si ostream sunt derivate din ios
clasa iostream este derivata din istream si
ostream si ofera metode pentru lucrul cu
dispozitivul standard de intrare/iesire .
clasa fstream ofera metode pentru operatii cu
fisiere.
Obiecte standard
Cand un program C++ care include iostream.h este
lansat in executie, sunt create si initializate
automat patru obiecte:

cin gestioneaza intrarea de la intrarea standard

(tastatura).
cout gestioneaza iesirea catre iesirea standard
(ecranul).
cerr gestioneaza iesirea catre dispozitivul
standard de eroare (ecranul), neutilizand buffere.

30

Exemplu:
#include <stdio.h>
#include <iostream>
#include <iomanip>
using namespace std;
class A{
static int d;
int m;
double t;
public:
A(){m=11; }
void afis()
{ //umple spatiul liber pana la dimensiunea data de setw(dim) cu
caracterul specificat
cout<<setfill('*')<<"m="<<setw(6)<<setfill('*')<<m<<";"<<endl;
cout<<"d="<<setw(7)<<setfill('_')<<d<<endl;
cout<<"m[hexa]="<<hex<<m<<endl;
t=5.1234567;
cout.precision(12);
cout<<"t1="<<t<<endl;
cout.precision(4);
cout<<"t2="<<t<<endl;
cout.precision(2);
cout<<"t3="<<t<<endl;
cout<<setprecision(5)<<"t4="<<t<<endl;

}
};
int A::d=8; //se declara ca variabila globala
int main(int argc, char **argv)
{
A x;
x.afis();
//std::cout<<"TEST";
//int m; std::cin>>m; // pe post de asteapta o tasta
}

31

FLUXURI DE INTRARE/IEIRE.
OPERATII DE INTRARE/IESIRE CU FISIERE
Lucrul cu fisiere se face prin intermediul clasei ifstream
pentru citire respectiv ofstream pentru scriere. Pentru a le
utiliza, aplicatiile trebuie sa includa fstream.h. Clasele
ofstream si ifstream sunt derivate din clasa iostream, ca
urmare toti operatorii si toate functiile descrise mai sus
sunt mostenite si de aceasta clasa.
Exemplu:
#include
#include
#include
#include

<stdio.h>
<iostream>
<iomanip>
<fstream>

using namespace std;

// FISIERE TEXT
class A{
public:
int scrie_in_Fisier(char* numefis)
{
ofstream fis1(numefis); //deschidere fiier text.txt
//ofstream fis1(numefis,ios::app|ios::out); //adauga, la
sfarsit, fara trunchiere fisier
if (!fis1){ cout<<"Eroare la dechiderea fiierului!\n";
return 1;}
fis1<<"A111 B222 ";
fis1<<"ABCD "; fis1<<15<<" "<<13;
fis1.close();
}
int citeste_din_Fisier(char* numefis)
{ char a[3][100];
int b[3];
ifstream fis2(numefis); //deschiderea fis. ptr. citire
if (!fis2){cout<<"Eroare la deschiderea fis. ptr.
citire!\n";return 1;}
fis2>>a[0]>>a[1]>>a[2]>>b[0]>>b[1];
cout<<"a[0]:"<<a[0]<<" a[1]:"<<a[1]<<" a[2]:"<<a[2]<<"
b[0]:"<<b[0]<<" b[1]:"<<b[1]<<endl;
fis2.close();
32

}
};
int main(int argc, char **argv)
{ A x;
x.scrie_in_Fisier("test24.txt");
x.citeste_din_Fisier("test24.txt");
return 0;
}

33

TRATAREA EXCEPIILOR
n timpul executrii unui program pot aprea situaii n care
sunt generate erori datorate de multe ori depirii puterii de
reprezentare a numerelor, de operaii nepermise, de contori n
afara limitelor admise, etc. Ca urmare este necesar
anticiparea unor posibile excepii, de multe ori provenite de
la preluarea incorect a datelor.
C + + ofer trei cuvinte cheie pentru a gestiona o excepie:
try , catch i throw.
Cuvntul cheie try este urmat de blocul ce se execut i care
poate genera o eroare n execuie
try { bloc ce se execut n mod normal}
Acest cuvnt cheie permite aplicaiei s anticipeze un
comportament anormal i va ncerca s se ocupe de ea.
catch { bloc ce se execut n cazul n care apare o
excepie/eroare }
Acest cuvnt cheie este urmat, ntre acolade, de blocul ce se
execut n cazul unei excepii/erori
throw transmite excepia, n vederea tratrii acesteia, ctre
sistemul de operare.
Ex:
#include <iostream>
using namespace std;
int main()
{
int a,b,c;
cout << "a= ";
cin >> a;
cout << "b= "; cin >> b;
try {
if( b==0 )
throw;
c = a / b;
}
34

catch()
{ cout<<b este zero;
}
cout << "\n";
return 0;
}

Cele trei puncte din argumentul catch semnific faptul c vor

fi tratate toate excepiile.
Pentru particularizarea tratrii erorii, putem proceda ca n
exemplul urmtor:
#include <iostream.h>
int main()
{
int a,b,c;
cout << "a= ";

cin >> a;

try {
cout << "b= "; cin >> b;
if(b == 0)
throw "b este ZERO !";
c = a / b;
}
catch(const char* Message)
{
cout << "Error: " << Message;
}
cout << "\n";
return 0;
}
n cazul n care sunt tratate mai multe excepii putem avea:
try {
//
codul ce poate contine exceptii/erori
}
catch(Arg1)
{
//tratarea primei excetii
}
catch(Arg2)
35

{
//tratarea urmatoarei exceptii
}
Deosebirea ntre argumente se va face prin tipurile acestora
Ex:
#include <iostream.h>
int main()
{
int a,b,c;
cout << "a= ";

cin >> a;

try {
cout << "b= "; cin >> b;
if(b == 0) throw "b este ZERO !";
if(b == 1) throw 1;
if(b == 2) throw '2';
c=a/b+a/(b-1)+a/(b-2);
catch(const char* Message)
{
cout << "Error: b=0;
}
catch(const int Message)
{
cout << "Error:b=1;
}
catch(const char Message)
{
cout << "Error: b=2";
}
cout << "\n";
return 0;
}

36

UTILIZAREA CLASELOR WXWIDGETS

Clasele wxWidgets se constituie ntr-un se de instrumente C++
ce permit

crearea

de interfae grafice

Interface)

n C++.

Aceste clase sunt

GUI (Graphical User

open source

platform. aplicaiile wxWidgets pot rula pe toate

i crosssub toate

sistemele de operare reprezentative: Linux, Windows, Unix si

Mac. Proiectul a fost demarat de ctre Julian inteligente n
1992.
Clasa wxString este utilizat pentru lucrul cu irurile de
caractere.
#include <wx/string.h>
int main(int argc, char **argv)
{ wxString str1 = wxT("Un");
wxString str2 = wxT("prim");
wxString str3 = wxT("exemplu.");
wxString str = str1 + wxT(" ") + str2 + wxT(" ") + str3;
wxPuts(str);
}
Formatarea irurilor
#include <wx/string.h>
int main(int argc, char **argv)
{
int a = 10;
wxString str;
str.Printf(wxT("a= %d\n",a);
wxPuts(str);
wxPrintf(wxT("irul are lungimea de %d caractere.\n"),
str.Len());
}
Clasa wxFile

este utilizat pentru lucrul cu fiiere

#include <wx/file.h>
int main(int argc, char **argv)
{
37

wxString str = wxT("Un sir de caractere.\n");

wxFile file;
file.Create(wxT("numefisier"), true);
if (file.IsOpened())
wxPuts(wxT("Fisierul este deschis"));
file.Write(str);
file.Close();
if (!file.IsOpened())
wxPuts(wxT("Fisierul NU este deschis"));
}

vederea

realizrii

interfeelor

grafice

este

necesar

utilizarea metodelor (din cadrul claselor date) ce asigur

gestiunea evenimentelor la nivel de aplicaie.
Ex:Realizarea unui mic formular utiliznd wxFormBuilder
gui.h --wxWidgets license (www.wxwidgets.org) -- fiier
generat de wxFormBuilder - necesar negerii structurii
claselor
#ifndef __gui__
#define __gui__
#include <wx/intl.h>
#include <wx/statline.h>
#include <wx/gdicmn.h>
#include <wx/font.h>
#include <wx/colour.h>
#include <wx/settings.h>
#include <wx/string.h>
#include <wx/sizer.h>
#include <wx/button.h>
#include <wx/dialog.h>
// Class MainDialogBase
class MainDialogBase : public wxDialog
{
private:

38

protected:
wxStaticLine* m_staticLine;
wxStdDialogButtonSizer* m_sdbSizer;
wxButton* m_sdbSizerOK;
wxButton* m_sdbSizerCancel;
virtual void OnCloseDialog( wxCloseEvent& event )
{ event.Skip(); }
virtual void OnCancelClick( wxCommandEvent& event )
{ event.Skip(); }
virtual void OnOKClick( wxCommandEvent& event )
{ event.Skip(); }
public:
MainDialogBase( wxWindow* parent, wxWindowID id =
wxID_ANY, const wxString& title = _("wxMiniApp"), const wxPoint&
pos = wxDefaultPosition, const wxSize& size = wxSize( 400,300 ),
long style = wxCLOSE_BOX|wxDEFAULT_DIALOG_STYLE );
~MainDialogBase();
};
#endif //__gui__

gui.cpp - wxWidgets license (www.wxwidgets.org) -- fiier

generat de wxFormBuilder - necesar negerii structurii
claselor
#include "gui.h"
MainDialogBase::MainDialogBase( wxWindow* parent, wxWindowID id,
const wxString& title, const wxPoint& pos, const wxSize& size, long
style ) : wxDialog( parent, id, title, pos, size, style )
{
this->SetSizeHints( wxSize( -1,-1 ), wxDefaultSize );
wxBoxSizer* mainSizer;
mainSizer = new wxBoxSizer( wxVERTICAL );
mainSizer->Add( 0, 0, 1, wxEXPAND, 5 );
39

m_staticLine = new wxStaticLine( this, wxID_ANY,

wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
mainSizer->Add( m_staticLine, 0, wxEXPAND | wxALL, 5 );
m_sdbSizer = new wxStdDialogButtonSizer();
m_sdbSizerOK = new wxButton( this, wxID_OK );
m_sdbSizer->AddButton( m_sdbSizerOK );
m_sdbSizerCancel = new wxButton( this, wxID_CANCEL );
m_sdbSizer->AddButton( m_sdbSizerCancel );
m_sdbSizer->Realize();
mainSizer->Add( m_sdbSizer, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT,
5 );
this->SetSizer( mainSizer );
this->Layout();
this->Centre( wxBOTH );
// conectarea handler-ului de evenimentelor
this->Connect( wxEVT_CLOSE_WINDOW,
wxCloseEventHandler( MainDialogBase::OnCloseDialog ) );
m_sdbSizerCancel->Connect( wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler( MainDialogBase::OnCancelClick ), NULL,
this );
m_sdbSizerOK->Connect( wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler( MainDialogBase::OnOKClick ), NULL, this );
}
MainDialogBase::~MainDialogBase()
{// Eliberarea handler-ului de evenimente
this->Disconnect( wxEVT_CLOSE_WINDOW,
wxCloseEventHandler( MainDialogBase::OnCloseDialog ) );
m_sdbSizerCancel->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler( MainDialogBase::OnCancelClick ), NULL,
this );
m_sdbSizerOK->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler( MainDialogBase::OnOKClick ), NULL, this );
}

40

main.h
#ifndef __main__
#define __main__
// main wxWidgets header file
#include <wx/wx.h>
// gui classes generated by wxFormBuilder
#include "gui.h"
class MainApp : public wxApp
{
public:
virtual bool OnInit();
};
DECLARE_APP(MainApp)
class MainDialog : public MainDialogBase
{
public:
MainDialog( wxWindow *parent );
virtual ~MainDialog();
protected:
virtual void OnCloseDialog( wxCloseEvent& event );
virtual void OnOKClick( wxCommandEvent& event );
virtual void OnCancelClick( wxCommandEvent& event );
};
#endif //__main__

main.cpp
#include "main.h"
IMPLEMENT_APP(MainApp);
bool MainApp::OnInit()
{
SetTopWindow( new MainDialog( NULL ) );
GetTopWindow()->Show();
return true;
}
MainDialog::MainDialog(wxWindow *parent) : MainDialogBase( parent )
{
}
MainDialog::~MainDialog()
{
}

41

void MainDialog::OnCloseDialog(wxCloseEvent& event)

{
Destroy();
}
void MainDialog::OnOKClick(wxCommandEvent& event)
{
Destroy();
}
void MainDialog::OnCancelClick(wxCommandEvent& event)
{
Destroy();
}

42