Cursul de programare orientata

pe obiecte
Seria 13
Saptamana 3, 4 martie 2014
Andrei Paun
Cuprinsul cursului: 4 martie 2014

Struct, Union si clase

functii prieten

Constructoridestructori

supraincarcarea functiilor in C!!

supraincarcarea operatorilor in C!!

Clasele in C!!

cu "class#

obiectele instantia$a clase

similare cu struct%uri si union%uri

au functii

specificatorii de acces: public, pri&ate, protected

default: pri&ate

protected: pentru mostenire, &orbim mai tar$iu

class class-name {
private data and functions
access-specifier:
data and functions
access-specifier:
data and functions
'''
access-specifier:
data and functions
} object-list;

putem trece de la public la pri&ate si iar la public, etc'

se foloseste mai mult a doua &arianta

un membru (ne%static) al clasei nu poate

a&ea initiali$are

nu putem a&ea ca membri obiecte de tipul

clasei (putem a&ea pointeri la tipul clasei)

nu auto, e*tern, register

class employee {
char name[80]; // private by default
public:
void putname(char *n); // these are public
void etname(char *n);
private:
double !ae; // no!" private aain
public:
void put!ae(double !); // bac# to public
double et!ae();
$;
class employee {
char name[80];
double !ae;
public:
void putname(char *n);
void etname(char *n);
void put!ae(double !);
double et!ae();
$;

&ariabilele de instanta (instance &ariabiles)

membri de tip date ai clasei

+
in general pri&ate
+
pentru &ite$a se pot folosi "public#
,*emplu
%include &iostream'
usin namespace std;
class myclass {
public:
int i" (" #; // accessible to entire proram
$;
int main()
{
myclass a" b;
a)i * +00; // access to i" (" and # is ,-
a)( * .;
a)# * a)i * a)(;
b)# * +/; // remember" a)# and b)# are different
cout && a)# && 0 0 && b)#;
return 0;
$
Struct si class

singura diferenta: struct are default membri

ca public iar class ca pri&ate

struct defineste o clasa (tip de date)

putem a&ea in struct si functii

pentru compatibilitate cu cod &ec-i

e*tensibilitate

a nu se folosi struct pentru clase

// 1sin a structure to define a class)
%include &iostream'
%include &cstrin'
usin namespace std;
struct mystr {
void buildstr(char *s); // public
void sho!str();
private: // no! o private
char str[/22];
$ ;
void mystr::buildstr(char *s){
if(3*s) *str * 4504; // initiali6e strin
else strcat(str" s);$
void mystr::sho!str() {cout && str && 05n0; $
int main() {
mystr s;
s)buildstr(00); // init
s)buildstr(07ello 0);
s)buildstr(0there30);
s)sho!str();
return 0;
$
class mystr {
char str[/22];
public:
void buildstr(char *s); // public
void sho!str();
$ ;
union si class

la fel ca struct

toate elementele de tip data folosesc aceeasi

locatie de memorie

membrii sunt publici (b. default)

%include &iostream'
usin namespace std;
union s!ap8byte {
void s!ap();
void set8byte(unsined short i);
void sho!8!ord();
unsined short u;
unsined char c[/];
$;
void s!ap8byte::s!ap()
{
unsined char t;
t * c[0];
c[0] * c[+];
c[+] * t;
$
void s!ap8byte::sho!8!ord()
{
cout && u;
$
void s!ap8byte::set8byte(unsined short i)
{
u * i;
$
int main()
{
s!ap8byte b;
b)set8byte(.90:.);
b)s!ap();
b)sho!8!ord();
return 0;
$
:22+9
union ca si class

union nu poate mosteni

nu se poate mosteni din union

nu poate a&ea functii &irtuale (nu a&em mostenire)

nu a&em &ariabile de instanta statice

nu a&em referinte in union

nu a&em obiecte care fac o&erload pe /

obiecte cu (conde)structor definiti nu pot fi

membri in union
union anonime

nu au nume pentru tip

nu se pot declara obiecte de tipul respecti&

folosite pentru a spune compilatorului cum

se tin &ariabilele respecti&e in memorie
+
folosesc aceeasi locatie de memorie

&ariabilele din union sunt accesibile ca si

cum ar fi declarate in blocul respecti&
%include &iostream'
%include &cstrin'
usin namespace std;
int main()
{
// define anonymous union
union {
lon l;
double d;
char s[.];
$ ;
// no!" reference union elements directly
l * +00000;
cout && l && 0 0;
d * +/:)/:./;
cout && d && 0 0;
strcpy(s" 0hi0);
cout && s;
return 0;
$
union anonime

nu poate a&ea functii

nu poate a&ea pri&ate sau protected (fara

functii nu a&em acces la altce&a)

union%uri anonime globale trebuie preci$ate

ca static
functii prieten

cu&antul: friend

pentru accesarea campurilor protected,

pri&ate din alta clasa

folositoare la o&erload%area operatorilor,

pentru unele functii de 01, si portiuni
interconectate (e*emplu urmea$a)

in rest nu se prea folosesc

%include &iostream'
usin namespace std;
class myclass {
int a" b;
public:
friend int sum(myclass ;);
void set8ab(int i" int ();
$;
void myclass::set8ab(int i" int () { a * i; b * (; $
// <ote: sum() is not a member function of any class)
int sum(myclass ;)
{
/* =ecause sum() is a friend of myclass" it can directly access a and b) */
return ;)a > ;)b;
$
int main()
{
myclass n;
n)set8ab(:" .);
cout && sum(n);
return 0;
$
%include &iostream'
usin namespace std;
const int ?@AB * 0;
const int ?<1CB * +;
class D/; // for!ard declaration
class D+ {
int status; // ?@AB if off" ?<1CB if on screen
// )))
public:
void set8status(int state);
friend int idle(D+ a" D/ b);
$;
class D/ {
int status; // ?@AB if off" ?<1CB if on screen
// )))
public:
void set8status(int state);
friend int idle(D+ a" D/ b);
$;
void D+::set8status(int state)
{ status * state; $
void D/::set8status(int state)
{ status * state; $
int idle(D+ a" D/ b)
{
if(a)status EE b)status) return 0;
else return +;
$
int main()
{
D+ ;;
D/ y;
;)set8status(?@AB);
y)set8status(?@AB);
if(idle(;" y)) cout && 0Ccreen can be used)5n0;
else cout && 0?n use)5n0;
;)set8status(?<1CB);
if(idle(;" y)) cout && 0Ccreen can be used)5n0;
else cout && 0?n use)5n0;
return 0;
$

functii prieten din alte obiecte

%include &iostream'
usin namespace std;
const int ?@AB * 0;
const int ?<1CB * +;
class D/; // for!ard declaration
class D+ {
int status; // ?@AB if off" ?<1CB if on screen
// )))
public:
void set8status(int state);
int idle(D/ b); // no! a member of D+
$;
class D/ {
int status; // ?@AB if off" ?<1CB if on screen
// )))
public:
void set8status(int state);
friend int D+::idle(D/ b);
$;
void D+::set8status(int state)
{
status * state;
$
void D/::set8status(int state)
{ status * state; $
// idle() is member of D+" but friend of D/
int D+::idle(D/ b)
{
if(F7?CG'status EE b)status) return 0;
else return +;
$
int main()
{
D+ ;;
D/ y;
;)set8status(?@AB);
y)set8status(?@AB);
if(;)idle(y)) cout && 0Ccreen can be used)5n0;
else cout && 0?n use)5n0;
;)set8status(?<1CB);
if(;)idle(y)) cout && 0Ccreen can be used)5n0;
else cout && 0?n use)5n0;
return 0;
$
clase prieten

daca a&em o clasa prieten, toate functiile

membre ale clasei prieten au acces la
membrii pri&ati ai clasei
// 1sin a friend class)
%include &iostream'
usin namespace std;
class F!oHalues {
int a;
int b;
public:
F!oHalues(int i" int () { a * i; b * (; $
friend class Iin;
$;
class Iin {
public:
int min(F!oHalues ;);
$;
int Iin::min(F!oHalues ;)
{ return ;)a & ;)b J ;)a : ;)b; $
int main()
{
F!oHalues ob(+0" /0);
Iin m;
cout && m)min(ob);
return 0;
$
functii inline

foarte comune in clase

doua tipuri: e*plicit (inline) si implicit

,*plicit
%include &iostream'
usin namespace std;
inline int ma;(int a" int b)
{
return a'b J a : b;
$
int main()
{
cout && ma;(+0" /0);
cout && 0 0 && ma;(99" 88);
return 0;
$
%include &iostream'
usin namespace std;
int main()
{
cout && (+0'/0 J +0 : /0);
cout && 0 0 && (99'88 J 99 : 88);
return 0;
$
functii inline

e*ecutie rapida

este o sugestiecerere pentru compilator

pentru functii foarte mici

pot fi si membri ai unei clase

%include &iostream'
usin namespace std;
class myclass {
int a" b;
public:
void init(int i" int ();
void sho!();
$;
// Dreate an inline function)
void myclass::init(int i" int ()
{ a * i; b * (; $
// Dreate another inline function)
inline void myclass::sho!()
{ cout && a && 0 0 && b && 05n0; $
int main()
{
myclass ;;
;)init(+0" /0);
;)sho!();
return 0;
$
2efinirea functiilor inline implicit
(in clase)
%include &iostream'
usin namespace std;
class myclass {
int a" b;
public:
// automatic inline
void init(int i" int () { a*i; b*(; $
void sho!() { cout && a && 0 0 && b && 05n0; $
$;
int main()
{
myclass ;;
;)init(+0" /0);
;)sho!();
return 0;
$
%include &iostream'
usin namespace std;
class myclass {
int a" b;
public:
// automatic inline
void init(int i" int ()
{
a * i;
b * (;
$
void sho!()
{
cout && a && 0 0 && b && 05n0;
$
$;
Constructori parametri$ati

trimitem argumente la constructori

putem defini mai multe &ariante cu mai

multe numere si tipuri de parametrii

o&erload de constructori
%include &iostream'
usin namespace std;
class myclass {
int a" b;
public:
myclass(int i" int () {a*i; b*(;$
void sho!() {cout && a && 0 0 && b;$
$;
int main()
{
myclass ob(:" 2);
ob)sho!();
return 0;
$
m.class ob / m.class(3, 4)3

a doua forma implica "cop. constructors#

discutat mai tar$iu

%include &iostream'
%include &cstrin'
usin namespace std;
const int ?< * +;
const int D7BD-B@8,1F * 0;
class boo# {
char author[.0];
char title[.0];
int status;
public:
boo#(char *n" char *t" int s);
int et8status() {return status;$
void set8status(int s) {status * s;$
void sho!();
$;
boo#::boo#(char *n" char *t" int s)
{
strcpy(author" n);
strcpy(title" t);
status * s;
$
void boo#::sho!()
{
cout && title && 0 by 0 && author;
cout && 0 is 0;
if(status**?<) cout && 0in)5n0;
else cout && 0out)5n0;
$
int main()
{
boo# b+(0F!ain0" 0Fom Ca!yer0" ?<);
boo# b/(0Ielville0" 0Ioby @ic#0" D7BD-B@8,1F);
b+)sho!();
b/)sho!();
return 0;
$
constructori cu un paramentru

se creea$a o con&ersie implicita de date

%include &iostream'
usin namespace std;
class K {
int a;
public:
K(int () { a * (; $
int eta() { return a; $
$;
int main()
{
K ob * 99; // passes 99 to (
cout && ob)eta(); // outputs 99
return 0;
$
4embri statici ai claselor

elemente statice: date, functii

4embri statici: de tip date

&ariabila precedata de "static#

+
o singura copie din acea &ariabila &a e*ista
pentru toata clasa
+
deci fiecare obiect din clasa poate accesa
campul respecti&, dar in memorie nu a&em
decat o singura &ariabila definita astfel
+
&ariabilele initiali$ate cu 0 inainte de crearea
primului obiect
+
o &ariabila statica declarata in clasa nu este
definita (nu s%a alocat inca spatiu pentru ea)
+
deci trebuie definita in mod global in afara
clasei
+
aceasta definitie din afara clasei ii aloca spatiu
in memorie
%include &iostream'
usin namespace std;
class shared {
static int a;
int b;
public:
void set(int i" int () {a*i; b*(;$
void sho!();$ ;
int shared::a; // define a
void shared::sho!(){
cout && 0Fhis is static a: 0 && a;
cout && 05nFhis is nonGstatic b: 0 && b;
cout && 05n0;$
int main(){
shared ;" y;
;)set(+" +); // set a to +
;)sho!();
y)set(/" /); // chane a to /
y)sho!();
;)sho!(); /* 7ere" a has been chaned for both ; and y
because a is shared by both ob(ects) */
return 0;$
5-is is static a: 1
5-is is non%static b: 1
5-is is static a: 2
5-is is non%static b: 2
5-is is static a: 2
5-is is non%static b: 1

C!! &ec-i 6U cerea redeclararea lui "a#

prin operatorul de re$olutie de scop ::

daca intalniti cod C!! &ec-i de acest tip

este 7,C14A62A809 sa se redefineasca
&ariabilele statice folosind sinta*a C!!
modern

2, C,: creea$a inconsitente

;ariabile statice de instanta

pot fi folosite inainte de a a&ea un obiect

din clasa respecti&a

in continuare: &ariabila de instanta definita

static si public

ca sa folosim o asemenea &ariabila de

instanta folosim operatorul de re$olutie de
scop cu numele clasei
%include &iostream'
usin namespace std;
class shared {
public:
static int a;
$ ;
int shared::a; // define a
int main()
{
// initiali6e a before creatin any ob(ects
shared::a * 99;
cout && 0Fhis is initial value of a: 0 && shared::a;
cout && 05n0;
shared ;;
cout && 0Fhis is ;)a: 0 && ;)a;
return 0;
$
<olosirea &ariabilelor statice de
instanta

semafoare: controlul asupra unei resurse pe

care pot lucra mai multe obiecte
%include &iostream'
usin namespace std;
class cl {
static int resource;
public:
int et8resource();
void free8resource() {resource * 0;$
$;
int cl::resource; // define resource
int cl::et8resource()
{
if(resource) return 0; // resource already in use
else {
resource * +;
return +; // resource allocated to this ob(ect
$
$
int main()
{
cl ob+" ob/;
if(ob+)et8resource()) cout && 0ob+ has resource5n0;
if(3ob/)et8resource()) cout && 0ob/ denied resource5n0;
ob+)free8resource(); // let someone else use it
if(ob/)et8resource())
cout && 0ob/ can no! use resource5n0;
return 0;
$
Alte e*emplu

6umararea obiectelor dintr%o clasa

%include &iostream'
usin namespace std;
class Dounter {
public:
static int count;
Dounter() { count>>; $
LDounter() { countGG; $
$;
int Dounter::count;
void f();
int main(void)
{
Dounter o+;
cout && 0,b(ects in e;istence: 0;
cout && Dounter::count && 05n0;
Dounter o/;
cout && 0,b(ects in e;istence: 0;
cout && Dounter::count && 05n0;
f();
cout && 0,b(ects in e;istence: 0;
cout && Dounter::count && 05n0;
return 0;
$
void f()
{
Dounter temp;
cout && 0,b(ects in e;istence: 0;
cout && Dounter::count && 05n0;
// temp is destroyed !hen f() returns
$
1b=ects in e*istence: 1
1b=ects in e*istence: 2
1b=ects in e*istence: 3
1b=ects in e*istence: 2

<olosirea &ariabilor statice de instanta

elimina necesitatea &ariabilelor globale

folosirea &ariabilelor globale aproape

intotdeauna &iolea$a principiul encapsularii
datelor, si deci nu este in concordanta cu
11P
functii statice pentru clase

au dreptul sa foloseasca doar elemente

statice din clasa (sau accesibile global)

nu au pointerul "t-is#

nu putem a&ea &arianta statica si non%statica

pentru o functie

nu pot fi declarate ca "&irtual# (legat de

mostenire)

folosire limitata (initiali$are de date statice)

%include &iostream'
usin namespace std;
class cl {
static int resource;
public:
static int et8resource();
void free8resource() { resource * 0; $
$;
int cl::resource; // define resource
int cl::et8resource()
{
if(resource) return 0; // resource already in use
else {
resource * +;
return +; // resource allocated to this ob(ect
$
$
int main()
{
cl ob+" ob/;
/* et8resource() is static so may be called
independent of any ob(ect) */
if(cl::et8resource()) cout && 0ob+ has resource5n0;
if(3cl::et8resource()) cout && 0ob/ denied resource5n0;
ob+)free8resource();
if(ob/)et8resource()) // can still call usin ob(ect synta;
cout && 0ob/ can no! use resource5n0;
return 0;
$

folosirea u$uala a
functiilor statice
%include &iostream'
usin namespace std;
class static8type {
static int i;
public:
static void init(int ;) {i * ;;$
void sho!() {cout && i;$
$;
int static8type::i; // define i
int main()
{
// init static data before ob(ect creation
static8type::init(+00);
static8type ;;
;)sho!(); // displays +00
return 0;
$
C-estiuni despre constructori si
desctructori

constructor: e*ecutat la crearea obiectului

destructor : e*ecutat la distrugerea

obiectului

obiecte globale: constructorii e*ecutati in

ordinea in care sunt definite obiectele
+
destructorii: dupa ce main s%a terminat in
ordinea in&ersa a constructorilor
%include &iostream'
usin namespace std;
class myclass {
int !ho;
public:
myclass(int id);
Lmyclass();
$ lob8ob+(+)" lob8ob/(/);
myclass::myclass(int id)
{
cout && 0?nitiali6in 0 && id && 05n0;
!ho * id;$
myclass::Lmyclass()
{ cout && 0@estructin 0 && !ho && 05n0;$
int main()
{
myclass local8ob+(:);
cout && 0Fhis !ill not be first line displayed)5n0;
myclass local8ob/(.);
return 0;
$
0nitiali$ing 1
0nitiali$ing 2
0nitiali$ing 3
5-is >ill not be first line displa.ed'
0nitiali$ing 4
2estructing 4
2estructing 3
2estructing 2
2estructing 1
1peratorul de re$olutie de scop ::
int i; // lobal i
void f()
{
int i; // local i
i * +0; // uses local i
)
)
)
$
int i; // lobal i
void f()
{
int i; // local i
::i * +0; // no! refers to lobal i
)
)
)
$
Clase locale

putem defini clase in clase sau functii

class este o declaratie, deci defineste un

scop

operatorul de re$olutie de scop a=uta in

aceste ca$uri

rar utili$ate clase in clase

e*emplu de clasa in functia f()

restrictii: functii definite in clasa

nu accesea$a &ariabilele locale ale

functiei

accesea$a &ariabilele definite

static

fara &ariabile static definite in

clasa
%include &iostream'
usin namespace std;
void f();
int main()
{
f();
// myclass not #no!n here
return 0;
$
void f()
{
class myclass {
int i;
public:
void put8i(int n) { i*n; $
int et8i() { return i; $
$ ob;
ob)put8i(+0);
cout && ob)et8i();
$
transmitere de obiecte catre functii

similar cu tipurile predefinite

call%b.%&alue

constructori%destructori?
// Massin an ob(ect to a function)
%include &iostream'
usin namespace std;
class myclass {
int i;
public:
myclass(int n);
Lmyclass();
void set8i(int n) { i*n; $
int et8i() { return i; $
$;
myclass::myclass(int n)
{
i * n;
cout && 0Donstructin 0 && i && 05n0;
$
myclass::Lmyclass()
{
cout && 0@estroyin 0 && i && 05n0;
$
void f(myclass ob);
int main()
{
myclass o(+);
f(o);
cout && 0Fhis is i in main: 0;
cout && o)et8i() && 05n0;
return 0;
$
void f(myclass ob)
{
ob)set8i(/);
cout && 0Fhis is local i: 0 && ob)et8i();
cout && 05n0;
$
Constructing 1
5-is is local i: 2
2estro.ing 2
5-is is i in main: 1
2estro.ing 1
2iscutie

apelam constructorul cand creem obiectul o

apelam de 21UA ori destructorul

la apel de functie: apel prin &aloare, o copie

a obiectului e creata
+
apelam constructorul:
+
la finali$are apelam destructorul:

9a apel de functie constructorul "normal#

6U ,S5, AP,9A5

se apelea$a asa%numitul "constructorul de

copiere#

un asemenea constructor defineste cum se

copia$a un obiect

se poate defini e*plicit de catre programator

+
daca nu e definit C!! il creea$a automat
Constructor de copiere

C!! il defineste pentru a face o copie

identica pe date

constructorul e folosit pentru initiali$are

constr' de copiere e folosit pentru obiect

de=a initiali$at, doar copia$a

&rem sa folosim starea curenta a obiectului,

nu starea initiala a unui obiect din clasa
respecti&a
destructori pentru obiecte transmise
catre functii

trebuie sa distrugem obiectul respecti&

c-emam destructorul

putem a&ea probleme cu obiecte care folosesc

memoria dinamic: la distrugere copia eliberea$a
memoria, obiectul din main este defect (nu mai are
memorie alocata)

in aceste ca$uri trebuie sa redefinim operatorul de

copiere (cop. constructor)
<unctii care intorc obiecte

o functie poate intoarce obiecte

un obiect temporar este creat automat pentru a tine

informatiile din obiectul de intors

acesta este obiectul care este intors

dupa ce &aloarea a fost intoarsa, acest obiect este

distrus

probleme cu memoria dinamica: solutie

polimorfism pe / si pe constructorul de copiere
// Neturnin ob(ects from a function)
%include &iostream'
usin namespace std;
class myclass {
int i;
public:
void set8i(int n) { i*n; $
int et8i() { return i; $
$;
myclass f(); // return ob(ect of type myclass
int main()
{
myclass o;
o * f();
cout && o)et8i() && 05n0;
return 0;
$
myclass f()
{
myclass ;;
;)set8i(+);
return ;;
$
copierea prin operatorul /

este posibil sa dam &aloarea unui obiect

altui obiect

trebuie sa fie de acelasi tip (aceeasi clasa)

// Ossinin ob(ects)
%include &iostream'
usin namespace std;
class myclass {
int i;
public:
void set8i(int n) { i*n; $
int et8i() { return i; $
$;
int main()
{
myclass ob+" ob/;
ob+)set8i(99);
ob/ * ob+; // assin data from ob+ to ob/
cout && 0Fhis is ob/4s i: 0 && ob/)et8i();
return 0;
$
#include<iostream.h>
class B
{ int i;
public: B() { i=1; }
virtual int et!i() { return i; }
};
class ": public B
{ int #;
public: "() { #=$; }
int et!i() {return B::et!i()%#; }
};
int main()
{ const int i = cin.et();
i& (i'() { " o;}
else {B o;}
cout<<o.et!i();
return );
}
#include <iostream.h>
class *
{ static int +;
public: *(int i=)) {+=i; }
int et!+() { return +; }
int, set!+(int i) { +=i;}
* operator=(* a1) { set!+(a1.et!+()); return a1;}
};
int main()
{ * a($1$)- b;
cout<<(b=a).et!+();
return );
}
#include<iostream.h>
class B
{ int i;
public: B() { i=1; }
virtual int et!i() { return i; } };
class ": virtual public B
{ int #;
public: "() { #=$; }
int et!i() {return B::et!i()%#; } };
class "$: virtual public B
{ int #$;
public: "$() { #$=(; }
int et!i() {return B::et!i()%#$; } };
class ..: public "- public "$
{ int +;
public: ..() { +="::et!i()%"$::et!i(); }
int et!i() {return +; } };
int main()
{ B /o= ne0 ..();
cout<<o1>et!i()<<23n2;
.. /p= d4namic!cast<../>(o);
i& (p) cout<<p1>et!i()<<23n2;
" /p$= d4namic!cast<"/>(o);
i& (p$) cout<<p$1>et!i()<<23n2;
return );
}
#include<iostream.h>
class B
{ protected: int +;
public: B(int i=$5) { +=i; }
virtual B &(B ob) { return +%ob.+%1; }
void a&isare(){ cout<<+; } };
class ": public B
{ public: "(int i=1($):B(i) {}
B &(B ob) { return +%ob.+11; } };
int main()
{ B /p1=ne0 "- /p$=ne0 B- /p(=ne0 B(p11>&(/p$));
p(1>a&isare();
return );
}