TESTE GRILA 1
.ex1 In contextul urmator ce constructor este
apelat ?
class numar {
private:
int num;
public:
numar( ) {num=0;} //(1)
numar(int n=0) {num=n;} //(2)
int val ( ) {return num;}
};
numar f ;
raspuns : Nici un constructor nu este apelat deoarece obtinem eroare de compilare .Cei doi constructori (1) si (2) genereaza ambiguitate .Pt. a elimina ambiguitatea va trebui sa schimbam constructorul cu argument implict (2)
intr-unul fara argument implicit astfel : numar(int n)
{num=n;}
ex.2 De cate ori este apelat constructorul
implicit al clasei calculator ?Dar destructorul implicit ?
calculator *calculatoare=new calculator[5];
….
delete calculatoare;
respuns: constructorul implicit al clasei calculator este
apelat de 5 ori ;destructorul o singura data datorita lipsei
parantezelor drepte [ ] .Pentru a apela de 5 ori destructorul :
delete [] calculatoare;
ex.3 Sa se specifice constructorii apelati .
class ceas {
private :
long secunde ;
punblic:
ceas( );
ceas(int m,int n,int s=0);
ceas (ceas & c);
};
void main( )
{
ceas a(9,30); //(a)
ceas b=a; //(b)
ceas c; //(c)
c=b; //(d)
}
raspuns :(a) este apelat constructorul cu trei argumente al treilea argument fiind implicit 0;
ex 4 De ce nu putem construi vectorul ?
class punct {
public:
int x,y;
punct(int a,int b) {x=a;y=b;}
};
punct dreptunghi[4];
raspuns: Este nevoie de constructor implicit de forma : punct(
) {x=0;y=0;} sau constructor cu argumente implicite punct(int
a=0,int b=0) { x=a;y=b;}
ex.5 Mentionati trei greseli strecurate in
declaratia destructorului urmatoarei clasei:
class imagine {
char *biti;
int latime,inaltime;
imagine (int 1,int i);
void ~imagine(char *mesaj);
};
raspuns: aceste aspecte care nu sunt corecte : destructorul
este privat ,are tip returnant ,are argumente.
ex.6 De ce o clasa nu poate avea mai mult de
un destructor ,chiar daca poate avea mai multi constructori?
raspuns: deoarece destructorii nu pot avea argumente acestea
nu pot fi supraincarcati (redefiniti).Reamintim ca lista de
argumente a unei functii este utilizata de catre compilator pt.a
determina existenta mai multor variante ale aceleiasi functii.
ex 7 Care din clase are constructor de
copiere ?
class e1{
int a,b,c;
public:
e1( );
e1(int,int);
e1(int,int,int);
};
class e2{
int a,b;
public:
e2(const e2 & );
e2(int,int);
};
a)e1 b)e2 c)ambele d)nici una e)nu se poate preciza descrierea este eronata
raspuns :
c) ambele
Atunci cand programatorul nu scrie constructorul de copiere
compilatorul pune el unul care initializeaza obiectul prin
copiere bit cu bit dintr-un obiect existent .
ex.8 .Fie clasa :
class c {
int a,b;
public:
float c(int,int);
int det_a ( ){return a;};
c( );
};
Declaratia float c(int,int) ar putea corespunde unui constructor al clasei?
a)da,fiind o supraincarcare a celui existent
b)nu,deoarece creaza ambiguitate
c)nu,deoarece constructorul nu are tip returnant
d)nu,deoarece nu este friend
raspuns:
c) nu,deoarece constructorul nu are tip returnat
Numele clasei este identificator unic si nu poate fi folosit
pt.metode sau functii independente ;folosit pt.o functie cu tip
returnat genereaza eroare de compilare ,deoarece un constructor
nu poate avea tip terurnat ,obiectul clasei fiind rezultatul
implicit al rularii constructorului.
ex.9 .Fie clasa :
class c{
int a,b;
public:
c(int,int);
int det_a( ){return a;}
~c( );
};
Semnul ~are rolul :
a)de a nega pe biti rezultatul returnat de metoda c( );
b)de a nega logic rezultatul returnat de metoda c( );
c)de a preciza existenta destructorului ;
d)de a supraincarca constructorul clasei;
e)de a supraincarca operatorul ~;
raspuns:
c) de a preciza existenta destructorului ;
Destructorul este apelat implicit la distrugerea obiectelor
create intr-un bloc.
ex.10 Fie programul :
class c{
int a;
public:
c ( );
c(const c &);
void operator =(c &);
};
void main( )
{
c a;
c b=a;
…
}
Linia c b=a; determina :
a)executia constructorului de copiere;
b)executia metodei prin care se supraincarca operatorul =
c)executia atat a constructorului de copiere cat si a metodei operator =
d)o eroare,deoarece nu se permite combinarea atribuirii cu o declaratie ;
e)executia constructorului implicit
raspuns:
a)executia constructorului de copiere;
Cand opratorul = apare la declaratia unui obiect atunci se executa constructorul de copiere ;constructia
c b=a se mai poate scrie c b(a) care sugereaza mai clar
executia constructorului de copiere .
ex.11 De cate ori se apeleaza destructorul
clasei in ex.urm?
#include <iostream.h>
class {
public:
~cls ( ) {cout<<"destructor "<<endl;}
};
void main ( )
{
cls r[3];
}
a)nici o data b)o data c)de doua ori d)de trei ori e)de patru ori
rapuns:
d)de trei ori
Fiind declarat un vector cu trei elemente tot atatea se vor si
distruge .Atentie nu e cu alocare dinamica de memorie sa fie
delete [ ] r ;
ex.12 De cate ori se apeleaza destructorul
clasei in ex.urm?
#include <iostream.h>
class cls{
public:
~cls( ){cout<<"destructor" <<endl;}
};
void main ( )
{
cls *po=new cls[3];
…
delete [ ] po;
}
a)nu se apeleaza nici o data
b)se apeleaza o data
c)se apeleaza eronat
d)se apeleaza de trei ori
e)se apeleaza de patru ori
raspuns :
d)se apeleaza de trei ori
Alocarea dinamica de memorie pt.obiecte cu opratorul new determina si executia constructorului iar dezalocarea cu delete determina executia destructorului .Fiind vorba de dezalocarea cu
delete [ ] a masivului de trei obiecte se va executa
destructorul de trei ori .
ex.13.#include<iostream.h>
class cls{
public:
cls( ) {cout<<constructor";}
cls(cls &c){cout<<"constructor de copiere";}
};
int f(cls c) {return 1;}
void main ( )
{
cls c;
f(c ) ;
}
La executia prg :
a)constructorul de clasa se apeleaza o data ,iar cel de copiere nici o data ;
b)constructorul de clasa si de copiere se apeleaza fiecare cate o data
c)constructorul de clasa nu se apelaza nici o data iar cel de copiere o data ;
d)constructorul de clasa se apeleaza de doua ori iar cel de copiere niciodata
e)constructorii de clasa si de copiere se apeleaza fiecare de cate doua ori .
raspuns:
b)constructorul de clasa si de copiere se apeleaza fiecare cate o data
La declararea obiectului c se executa constructorul de clasa
(implicit)iar la transmiterea obiectului prin valoare ca
parametru functiei f( ) se executa constructorul de copiere pt.a
copia parametrul (obiectul) pe stiva .
ex. 14.#include<iostream.h>
class cls{
public:
cls( ) {cout<<constructor";}
cls(cls &c){cout<<"constructor de copiere";}
};
int f(cls &c) {return 1;}
void main ( )
{
cls c;
f(c ) ;
}
La executia prg :
a)constructorul de clasa se apeleaza o data ,iar cel de copiere nici o data ;
b)constructorul de clasa si de copiere se apeleaza fiecare cate o data
c)constructorul de clasa nu se apelaza nici o data iar cel de copiere o data ;
d)constructorul de clasa se apeleaza de doua ori iar cel de copiere niciodata
e)constructorii de clasa si de copiere se apeleaza fiecare de cate doua ori .
raspuns:
a)constructorul de clasa se apeleaza o data ,iar cel de copiere nici o data
Se transmite functiei o referinta la obiect adica o adresa si
aceasta se va copia pe stiva nu obiectul deci constructorul de
copiere nu se executa .
ex.15 De cate ori este apelat constructorul de
copiere la un singur apel al functiei?
ceas &ticaie (ceas &c ,int sec)
{
for(int i=0;i<=sec;i++) c.tic_tac( );
return c;
}
raspuns :
Niciodata .Obiectul de tip ceas este pasat prin referinta si
returnat tot prin referinta .
ex. 16 #include<iostream.h>
class cls{
public:
cls( ) {cout<<constructor";}
cls(cls &c){cout<<"constructor de copiere";}
};
int f(cls *c ) {return 1;}
void main ( )
{
cls c;
f( &c ) ;
}
La executia prg :
a) constructorii de clasa si de copiere se apeleaza fiecare de cate doua ori .
b)constructorul de clasa si de copiere se apeleaza fiecare cate o data
c)constructorul de clasa nu se apelaza nici o data iar cel de copiere o data ;
d)constructorul de clasa se apeleaza de doua ori iar cel de copiere niciodata
e) constructorul de clasa se apeleaza o data ,iar cel de copiere nici o data ;
raspuns:
e)constructorul de clasa se apeleaza o data ,iar cel de copiere nici o data
Se transmite functiei adresa obiectului ceea ce nu
implica copierea pe stiva a obiectului deci constructorul de
copiere nu se executa .
ex.17.#include<iostream.h>
class cls{
public:
cls( ) {cout<<constructor";}
cls(cls &c){cout<<"constructor de copiere";}
};
cls f( ) {
cls c; // apel constructor clasa
return c; //apel constructor copiere
}
void main ( )
{
cls r; //apel constructor clasa
r=f( ) ; // nu se apeleaza nici un constructor deoarece este o simpla atribuire si nu o initializare
}
La executia prg :
a)constructorul de clasa se apeleaza o data ,iar cel de copiere nici o data ;
b)constructorul de clasa si de copiere se apeleaza fiecare cate o data
c)constructorul de clasa nu se apelaza nici o data iar cel de copiere o data ;
d)constructorul de clasa se apeleaza de doua ori iar cel de copiere o data;
e)constructorii de clasa se apeleaza o data ,iar cel de copiere se apeleaza de doua ori .
raspuns:
d)constructorul de clasa se apeleaza de doua ori iar cel de copiere o data
La declaratia obiectului r se executa constructorul de clasa
;in functia f( )se declara obiectul c pt.care se executa
constructorul de clasa .La returnarea din functie a obiectului
c se executa constructorul de copiere .
ex.19 .#include<iostream.h>
class cls{
public:
cls( ) {cout<<constructor";}
cls(cls &c){cout<<"constructor de copiere";}
};
cls &f( )
{
static cls c; // apel constructor clasa
return c; //nu se apeleaza constructorul copiere deoarece se returneaza o referinta la obiect
}
void main ( )
{
cls r; //apel constructor clasa
r=f( ) ; // nu se apeleaza nici un constructor deoarece este o simpla atribuire si nu o initializare
}
La executia prg :
a)constructorul de clasa se apeleaza o data ,iar cel de copiere nici o data ;
b)constructorul de clasa si de copiere se apeleaza fiecare cate o data
c)constructorul de clasa nu se apelaza nici o data iar cel de copiere o data ;
d)constructorul de clasa se apeleaza de doua ori iar cel de copiere nici o data;
e)constructorii de clasa se apeleaza o data ,iar cel de copiere se apeleaza de doua ori .
raspuns:
d)constructorul de clasa se apeleaza de doua ori iar cel de copiere nici o data
La declaratia obiectului r se executa constructorul de clasa
;in functia f( )se declara obiectul c pt.care se executa
constructorul de clasa .Se returneaze din functie o referinta
la obiect ceea ce nu determina executia constructorul de copiere.
ex.20.#include<iostream.h>
class cls{
public:
~cls( ) {cout<<"destructor";}
};
cls f( ){
cls c; //se apeleaza constructorul de clasa si la iesirea din bloc destructorul
return c; //se apeleaza constructorul de copiere si la iesirea din bloc destructorul
}
void main( )
{
cls r; //se apeleaza constructorul de clasa si la iesirea din bloc destructorul
r=f( );
}
Destructorul de clasa in ex.de mai sus:
a)se apeleaza o data
b)nu se apeleaza nici o data
c)se apeleaza de doua ori
d)se apeleaza de trei ori
e)este eronat ;
raspuns :
d)se apeleaza de trei ori
Destructorul se executa pt.obiectul r ; pt.obiectul c declarat
local in functia f( ) iar pt.copia care este construita cand se
executa return c se mai executa inca o data destructorul clasei.
ex.21 .#include<iostream.h>
struct persoana {
char nume[20];
struct copil{
char prenume[10];
int varsta;
} c[3];
}p1,*pp;
void main ()
{ pp=&p1;
p1.c[0].varsta=5;
p1.c[1].varsta=10;
p1.c[2].varsta=15;
cout<<pp->c->varsta<<endl; //afisa 5
cout<<pp->c[1].varsta<<endl; //afisa 10
cout<<(pp->c+2)->varsta<<endl; //va afisa 15 ;+2 indica de la al catelea index sa afiseze
cout <<((*pp).c)->varsta<<endl; // va afisa 5
cout<<(*pp).c[1].varsta<<endl; //va afisa 10
cout<<(*pp).c->varsta<<endl; //va afisa 5
}
Care din expresiile sunt corecte ?
cout<<pp->c->varsta<<endl; //afisa 5
cout<<pp->c[1].varsta<<endl; //afisa 10
cout<<(pp->c+2)->varsta<<endl; //va afisa 15 ;+2 indica de la al catelea index sa afiseze
cout <<((*pp).c)->varsta<<endl; // va afisa 5
cout<<(*pp).c[1].varsta<<endl; //va afisa 10
cout<<(*pp).c->varsta<<endl; //va afisa 5
a)2+5 b)toate sunt corecte c)2+5+6 d)1+2+5+6 e)1+2+3+5+6
raspuns :
b)toate sunt corecte
Ex.demonstreaza multitudinea formelor de adresare a unui
membru dintr-o clasa inclusa intr-o alta clasa
ex.22 .#include<iostream.h>
#include<string.h>
class copil {
int varsta ; // se declara in zona public pt.apelul p.c.varsta
public :
char prenume[20];
copil(int v=1,char *pren="puiu") : varsta(v) {strcpy(prenume,pren);}
};
class persoana{
int varsta ;
public:
copil c;
persoana(int v1=18,int v2=3,char pren[] ="puiu") : varsta(v1),c(v2,pren){}
};
void main ()
{
persoana p1(30,5,"sandu");
cout<<p1.c.prenume<<"are"<<p1.c.varsta<<"ani";//pt.a avea acces se pune varsta in zona public
}
a)prg.afiseaza "puiu are 0 ani "
b)prg.afiseaza "sandu are 5 ani"
c)obiectul persoana nu are acces in zona private a clasei copil inclusa
d)prg este eronat, clasa copil trebuie sa fie declarata in clasa persoana
e)nu este permisa includere unor obiecte in altele
raspuns :
c) obiectul persoana nu are acces in zona private a clasei
copil inclusa
ex.23 #include<iostream.h>
class cls {
public:
auto int i;
static int s;
register int r;
extern int e;
};
Care din clasele de memorie 1-automatic 2-static 3-register 4-extern nu pot fi aplicate membrilor unei clase de obiecte ?
a)3+4 b)1+2 c)1+2+3 d)4 e)1+3+4
raspuns:
e)1+3+4
Singura clasa de memorie care se poate asocia unui membru al
unei clase este static.
ex.24 De ce nu putem utiliza variabilele
globale in locul membrilor statici ?Nu servesc aceluiasi scop?
raspuns:
Variabilele globale au acelasi scop ca si cel al membrilor statici .
Variabilele globale nu pot fi ascunse in interiorul unei clase daca s-ar putea ascunde nu ar mai fi variabile globale
ele incalca principiul incapsularii.
ex.25 Care este greseala in initializarea
membrilor statici xactiv si yactiv ?
class cursor{
static int xactiv,yactiv; //se poate face in fisier header
int x,y;
cursor(int xi ,int yi );
};
cursor : : xactiv=42; //nu se face in fisier header
static : : int yactiv=17; //nu se face in fisier header
raspuns:
1.la initializarea lui xactiv s-a omis tipul de date al acestuia corect este : int cursor : : xactiv=42;
2. la initializarea lui yactiv nu s-a specificat clasa de provenienta
3. la initializarea lui yactiv s-a folosit eronat cuvantul
static corect este : int cursor : : yactiv=17;
ex.26 .#include<iostream.h>
class cls{
public:
static int s;
};
int cls :: s=0;
void main ( )
{
int i=7;
cls :: s=i;
cout<<cls::s;
}
Utilizarea lui s este:
a)ilegala ,deoarece nu exista nici un obiect creat ;
b)ilegala,deoarece s este incomplet specificat;
c)corecta,deoarece membrii statici exista inainte de a se crea obiecte din clasa
d)ilegala,deoarece variabilele statice pot fi doar private ;
e)ilegala,deoarece s este dublu definit in clasa si in afara ei ;
raspuns:
c)corecta,deoarece membrii statici exista inainte de a se
crea obiecte din clasa
ex.27 Fie clasa :
class persoana{
int npers;
char nume[50];
public:
persoana( );
int nr_persoane( ){return npers;}
};
Daca se doreste ca variabila npers sa contorizeze numarul tuturor obiectelor care apartin clasei persoana atunci ea trebuie definita ca variabila :
a)friend b)virtuala c)statica d)inline e)register
raspuns :
c)statica
Variabilele care nu iau valori specifice fiecarui obiect in
parte se declara statice ;ele apartin clasei prin faptul ca
informatia continuta se refera la clasa in ansamblul ei .
ex 28 Semnalati greseala existenta in legatura
cu functia membra statica din codul urmator :
class vector{
public :
int data[10];
static int primul( );
};
int vector :: primul( )
{
return data[0];
}
raspuns:
Greseala este aceea ca functia membra statica primul ( ) incearca sa aceseze un membru nestatic .
Pt.a rezolva problema :
-fie declaram functia membra nestatica ;
-ori ii vam atasa acesteia in lista de argumente un vector astfel:
int vector::primul( vector &x)
{
return x[0];
}
ex 29 Daca o clasa are toti membrii statici
,este posibil sa o utilizam fara sa declaram un obiect avand
tipul acesteia?
raspuns:
Da .
Din moment ce membrii statici apartin tuturor obiectelor de
tipul clasei respective ,dar nici unuia in particular ,si cum
functiile membre statice pot fi apelate fara a utiliza
un obiect , este posibil sa utilizam o clasa statica fara a
declara obiecte avand tipul ei .
ex.30 O metoda statica a unui obiect se
caracterizeaza prin :
a)nu primeste pointerul la obiect this ;
b)poate fi apelata doar de catre metodele obiectului ;
c)foloseste numai datele private ;
d)nu poate fi definita decat inline;
e)foloseste numai datele publice ;
raspuns:
a)nu primeste pointerul la obiect this ;
Metodele statice primesc obiectele ca parametrii expliciti.
ex.31 .O functie friend difera de o
metoda obisnuita a unei clase prin faptul ca :
a)nu primeste pointerul implicit la obiect this ;
b)nu poate accesa decat partea publica a obiectului
c)nu se poate defini inline ;
d)se foloseste doar pentru supraincarcarea operatorilor ;
d)nu poate returna valori
raspuns:
a) nu primeste pointerul implicit la obiect this ;
O functie friend ramane independenta de clasa ,ea primind doar drepturi speciale de acces la membrii clasei .
Pentru a lucra pe obiecte ea primeste obiectul ca parametru
prin referinta ,nu implicit prin pointerul this cum este cazul
functiilor membre nestatice .
ex.32 O functie independenta declarata friend
in domeniul public dintr-o clasa si care primeste ca
parametru o referinta la un obiect al clasei respective are acces
:
a)doar la membrii public;
b)la toti membrii ;
c)la membrii public si protected ;
d)la membrii protected ;
e)la toti membrii ,dar ii poate doar consulta nu si modifica ;
raspuns:
b)la toti membrii ;
Fiind functie friend poate accesa toti membrii prin
intermediu referintei la obiectul primit ca parametru in functie
fara nici o restrictie indiferent in ce sectiune a fost declarata
ex.33 O functie independenta declarata friend
in domeniul private dintr-o clasa si care primeste ca
parametru o referinta la un obiect al clasei respective are acces
:
a)doar la membrii public;
b)la toti membrii ;
c)la membrii public si protected ;
d)la membrii private ;
e)la toti membrii ,dar ii poate doar consulta nu si modifica ;
raspuns:
b)la toti membrii ;
ex.34 .Fiind date clasele :
class ex1;
class ex2{
public:
friend class ex1; // clasa ex1 este friend al clasei ex2;
};
class ex1{ … };
Relatia dintre clase este :
a)clasa ex1 este friend al clasei ex2;
b)clasa ex2 este friend al clasei ex1;
c)relatia de prietenie este reciproca ;
d)eronata ,pt.ca numai functiile pot fi friend ;
e)eronata ,deoarece se face in sectiunea publica
raspuns : a)clasa ex1 este friend al clasei ex2;
ex.35 .#include<iostream.h>
class X
{
int x;
public:
X(int n=0):x(n){}
friend class Y;
};
class Y
{
int y;
friend class Z;
};
class Z
{
public:
void f(X ox) {cout<<ox.x;} //nu se poate
};
void main( )
{X ox; Z oz; oz.f(ox); }
a)apelul functiei f( )nu concorda cu prototipul
b)ox.x nu este accesibil ,caci atributul friend nu este tranzitiv;
c)clasa Y actioneaza ca mediator de acces intre clasele Z si X
d)relatia friend este reciproca
e)variabila ox.x este de acces public
raspuns :
b)ox.x nu este accesibil ,caci atributul friend nu este
tranzitiv
Clasa Y are acces total la clasa X,clasa Z are acces total la
clasa Y nu la clasa X
ex.36 #include<iostream.h>
class ex1;
class ex2
{
int a;
public:
int b;
friend class ex1;
protected :
int c;
};
class ex1
{
public:
void f(ex2 &ob) {cout<<ob.a<<ob.c;}
};
void main( )
{
ex1 ob1;
ex2 ob2;
ob1.f(ob2);
}
a)f( )are acces la toti membrii clasei ex2;
b)f( ) are acces doar la variabila publica b ,deoarece declaratia de friend este data in domeniul public
c)f( ) are acces doar la variabilele publice si protected (variabilele b si c )
d)f( ) nu are acces la nici una variabilele a,b,c
e)functia f ( ) este incorect apelata
raspuns:
a)f( )are acces la toti membrii clasei ex2;
ex.37 #include<iostream.h>
class cls{
int x;
public:
friend void f(cls);
};
void f(cls c) {cout<<c.x<<endl;}
void f(cls c, int i) {cout<<c.x<<endl;}
void main ( )
{
cls c;
f(c) ;
f(c,1);
}
a)friend actioneaza implicit pt.toate versiunile lui f
b)nu se poate declara friend functii ce returneaza void
c)fiecare versiune a unei functii poate fi declarata friend
d)functiile supraincarcate nu pot fi declarate friend
e)exemplul functioneaza fara nici o modificare
raspuns:
c)fiecare versiune a unei functii poate fi declarata friend
Atributul de friend are efect numai pt.versiunea de
supraincarcare pt. care a fost declarat .
ex 38
class info{
private:
int data_privata;
public:
int data_publica;
void interior(int p);
friend int exterior(info *a);
};
void info::interior (int p) {data_privata=p; } //(a)
int exterior(info *a){return a->data_privata;} //(b)
int Externa (info *a) {return a->data_privata;} //(c )
Care functii sunt legale ?
raspuns : functiile (a) si (b) sunt corecte .
ex39. Functiile friend si functiile membre
statice
se aseamana :
- datorita faptului ca nu poseda pointerul this .
se deosebesc :
-functiile friend pot fi membre ale altor clase iar functiile membre statice nu pot fi.
-functiile friend se folosesc cand avem clase in legatura si se doreste fortarea accesului catre elementele private
-functiile membre statice se folosesc cand se manevreaza date
statice si clase statice (toate elementele sunt declarate
static)
ex.40 class persoana {
char nume[50];
int varsta;
public:
persoana ( );
int spune_varsta( ) {return varsta;}
};
Functia int spune_varsta( ) este :
a)functie inline b)functie friend c)functie virtuala
d)eronata deorece variabila varsta este privata
raspuns:
a)functie inline
Functiile reduse ca dimensiune ,cu mare stabilitate in timp si
cu frecventa mare de apel pot fi declarate inline apelul lor
inlocuindu-se cu codul executabil.
ex.41.class C { float a; void afis_a ( ) ;};
are membrii:
a)publici b)privati c)date private si metode publice d)protected
e)descrisi eronat nu declara tipul de acces (domeniile de acces )
respuns :
b)privati
Daca nu apar explicit domeniile de acces ,implicit toti membrii clasei sunt privati .
Proiect realizat de MARTON (POP) CLAUDIA an IV Ianuarie 2005