Admin
Administrator
 Inregistrat: acum 14 ani
Postari: 315
|
|
Atributele unei date utilizate in C++ sunt:
- tipul care indica modul de memorare si operatiile permise;
- clasa de memorie prin care se specifica locul unde este memorata data respectiva;
- durata de existenta care reprezinta intervalul de timp in care exista acea data;
- accesibilitatea care arata posibilitatea de acces la acea data;
- scopul care pune in evidenta domeniul de vizibilitate al datei.
Conectarea unor astfel de atribute (cunoscute din ANSI C) la variabile, poate fi:
1. statica (interna) - in faza de compilare compilare ;
2. dinamica - in faza de executie a programului ;
3. externa - cand datele utilizate in modulul curent, apartin unui alt modul.
Exista concepte care nu se pot implementa in limbajul C++, folosind tipurile predefinite de date, cum ar fi: sir de caractere, numar complex, lista, arbore etc. Pentru un astfel de concept se va defini de catre utilizator un tip abstract de date, care consta intr-o colectie de date ce admit aceeasi reprezentare impreuna cu setul de operatii ce se pot efectua cu aceste date.
In OOP, clasa constituie o generalizare a notiunii de tip de date, un ansamblu de obiecte similare (aceeasi structura a datelor actionate de aceleasi metode). Tipul abstract de date, definit de utilizator printr-o clasa, se comporta ca un tip predefinit. Cel mai frecvent tip_clasa, utilizat in programarea orientata pe obiect, este class. Un obiect reprezinta un element (o instanta) al clasei respective. Clasa o putem interpreta ca o abstractizare logica, iar obiectul de tipul clasei respective, ca o existenta fizica. Compilatorul ascunde detaliile interne ale acestui tip de date fata de mediu extern.
Definitia unei clase cuprinde:
a) declaratia clasei (specificarea datelor si prototipurilor functiilor componente, definitiile functiilor inline) intr-un fisier antet ( care are identificatorul incheiat cu .h sau .hpp);
b) implementarea clasei (definitiile functiilor componente) pastrata intr-un alt fisier ( pentru unele compilatoare identificatorul unui astfel de fisier se incheie cu .cpp).
Declararea unei clase este similara cu a unei structuri:
class id-clasa {
// date si functii particulare
specificator de acces:
// date si functii
} lista de obiecte;
Lista de obiecte este optionala.
In mod implicit, datele si functiile declarate intr-o clasa devin proprii clasei respective. De aceea, ele se vor numi date membre, respectiv functii membre (metode) ale acelei clase.
Domeniul unui identificator de clasa este local si incepe din momentul declararii clasei si se incheie la finele blocului respectiv. Daca o clasa este declarata in afara oricarei functii, domeniul sau este intregul fisier. Domeniul membrilor unei clase coincide cu domeniu clasei respective.
In general, o clasa contine:
- o parte protejata care are rolul de a asigura implementarea clasei;
- o parte publica care reprezinta interfata clasei respective cu celelalte clase prezente in program.
Protectia membrilor intr-o clasa se asigura cu ajutorul unor specificatori de acces / modificatori de protectie: public, protected, private. Intr-o clasa, la finalul cuvantului cheie, care precizeaza modul de acces, se afla intotdeauna ":".
La membrii aflati sub actiunea specificatorului private se permite accesul doar prin functiile membre ale clasei respective si prin functii friend (prieten) ale sale (vezi L 5).
Membrii unei clase, declarati in sectiunea public, pot fi accesati si din alte puncte ale programului C++, din exteriorul clasei respective.
Specificatorul protected are aceleasi caracteristici ca si private, in plus, membrii astfel protejati sunt accesibili si claselor derivate (vezi L7).
Prototipurile functiilor membre se afla in declaratia clasei respective, iar definitiile lor (cu exceptia celor inline) se dau in exteriorul declaratiei clasei, folosind operatorul de rezolutie de domeniu "::". Acesta indica faptul, ca domeniul functiei respective este acelasi cu domeniu clasei din care face parte.
Sintaxa definitiei unei functii membre a unei clase:
tip id_clasa::id_func_membra(...){...};
Exemplu:
class A
{ //declarare clasa
private:
int u,v,w; //declarare (explicita) de variabile membre protejate
public:
void prelucreaza(int fu,int fv,int fw); //prototip functie membra publica
};
void A::prelucreaza(int fu,int fv, int fw) //definirea functiei membra
{
u+=fu;
v+=fv;
w+=fw;
}
A o1,o2,o3; // instantieri ale clasei A
O instantiere a unei clase consta in declararea unei variabile (un obiect) de tipul clasei respective.
Prin constructia
o1.prelucreaza(3,4,5);
se observa ca obiectul o1 apeleaza functia membra "prelucreaza" cu parametrii efectivi 3,4,5.
Efectul consta in adunarea acestor valori la valorile variabilelor membre corespunzatoare lui o1.
In C++, obiectele unei clase se pot manipula folosind functiile membre si operatorii definiti pentru acea clasa. O astfel de functie, ca si in C, accepta, de regula, unul sau mai multi parametri si returneaza o valoare. Mecanismul de transmitere prin valoare consta in primirea de catre functie a parametrilor actuali intr-o stiva (stack), care este o structura de date de tip LIFO. Aceasta functie preia parametrii din stiva si ii foloseste in blocul sau, fara a avea acces la locatiile lor de memorie. Ea foloseste doar copii locale ale acestor parametrii, care vor fi eliminate din stiva la revenirea din functie. Prin urmare, printr-un astfel de mecanism, functia respectiva nu-si poate modifica parametrii cu care a fost apelata.
In C++, se utilizeaza conceptul de referinta, nume alternativ pentru un obiect, care poate fi utilizat la fel ca obiectul referit. Referinta reprezinta adresa obiectului respectiv, deosebindu-se de pointer prin faptul, ca ea nu este o variabila reala. Ea este initializata in momentul definirii si valoarea ei nu se poate modifica ulterior.
Exemplu:
int *p ; // pointer la un intreg (neinitializat)
int &a_1=a; //referinta la o variabila intreaga
Exemplu:
void acces(int &a, int v){a=v;}
Se observa ca a este un parametru de tip referinta. Exista diferente intre apelul cu pointeri si apelul cu referinte. Operatorul de apartenenta, in prima situatie, este ->, iar, in a doua situatie, este ..
Exemplu:
int k;
acces(k,30); //apelul functiei cu parametru tip referinta. Nu se transmite adresa.
Exemplu:
// transmiterea parametrilor prin pointer, referinta, valoare
struct data_c
{
int zi;
int luna;
int an;
}
void ind_dat(data_c *d) // parametru - pointer
{
int z,l,a;
z=d->zi;
cout<<z<<n>luna;
cout<<l<<n>an;
cout<<a<<\n;
}
void ind_dat_1(data_c &d) //parametru - referinta
{
int z,l,a;
z=d.zi;
cout<<z<<\n;
l=d.luna;
cout<<l<<\n;
a=d.an;
cout<<a<<\n;
}
void ind_dat_2(data_c d) //parametru - valoare
{
int z,l,a;
z=d.zi;
cout<<z<<\n;
l=d.luna;
cout<<l<<\n;
a=d.an;
cout<<a<<\n;
}
// Apelul:
data_c data_crt;
int_dat(&data_crt);
int_dat_1(data_crt);
int_data_2(data_crt);
Ca o concluzie, referinta se foloseste in transmiterea de parametri, daca:
a) functia trebuie sa modifice parametrii actuali de la apel;
b) functia nu modifica parametrii actuali, dar trebuie evitata copierea obiectelor in stiva (economie de memorie).
In acest ultim caz, se va folosi specificatorul const, pentru a indica faptul, ca parametrul transmis prin referinta, nu trebuie modificat de functia respectiva.
Exemplu:
void ind_dat_3(data_c const &d)
{
int z,l,a;
z=d.zi;
cout<<z<<\n;
l=d.luna;
cout<<l<<\n;
a=d.an;
cout<<a<<\n;
}
In aceasta situatie nu exista riscul ca functia sa modifice, in mod accidental, parametrul.
Valoarea returnata de functie poate fi o referinta la un obiect, daca dorim sa folosim aceasta valoare ca membru stang al unei atribuiri. Acest lucru este valabil doar atunci cand suntem asigurati de faptul, ca obiectul respectiv exista si dupa revenirea din functie.
Exemplu:
// urmatoarea functie va returna o copie a celui de al k-lea element dintr-un //sir? Explicati ce se intampla in urmatoarele situatii.
char tab(char*s, int k)
{ return s[k];}
char &tab(char *s, int k)
{ return s[k];}
char ch;
char*s=INFORMATICA;
ch=tab(s,10);
ch=I;
Intr-o declaratie de clasa se poate modifica accesul ori de cate ori este necesar.
Exemplu:
# include<iostream>
# include <string>
class salariat
{ char nume[30]; // data membra ( declarata la fel ca in C )
public:
void scrie_n(char *n);
void cit_n(char *n);
private:
double salariu;
public:
void scrie_s(double s);
double cit_s( );
};
void salariat ::scrie_n(char *n)
{
strcpy(nume,n);
}
void salariat::cit_n(char *n)
{
strcpy(n,nume);
}
void salariat ::scrie_s(double s)
{salariu=s;}
double salariat ::cit_s( )
{return salariu;}
main ( ){
salariat George;
char nume[30];
George.scrie_n("George Popescu" ;//accesarea cu operatorul "."
George.scrie_s(800000);
George.cit_n(nume);
cout<<nume<<"are suma:";
cout<<George.cit_s( )<<"pe luna";
return 0;
}
Tipurile struct si union reprezinta cazuri particulare de clase care se distanteaza de conceptul OOP.
Diferente intre class si struct:
- datele membre in struct, in mod implicit, sunt publice.
- membrii din class, in mod implicit, sunt protejati privat.
Operatorul :: mai este numit si operator de scop. Scopul si accesibilitatea unui identificator se pune in evidenta cu ajutorul acestui operator.
Sintaxa:
::variabila operator;
Exemplu:
..
int i; // declararea lui i ca variabila globala
void f1(void)
{
int i; // declararea lui i ca variabila locala in functia f1
..
i++; // incrementarea lui i, variabila locala in functia f1
..
}
void f2(void)
{
int i; // declararea lui i ca variabila locala in functia f2
::i++; // incrementarea lui i global desi este mascat de declararea unui i
// local
..
}
In stanga operatorului :: se poate afla cel mult un identificator de clasa.
In C++, variabilele locale pot fi create in orice pozitie din cod.
Exemplu:
// utilizam C++ ca extensie a lui C
# include <stdio>
int k=70; //variabila globala
int main( )
{
..
for(register int k=1; k<30>succ=succ;
p->prec=this;
succ->prec=p;
succ=p; }
In ultimele instructiuni, daca am utiliza in mod explicit operatorul this, ar rezulta:
p->succ=this->succ;
this->succ->prec=p;
this->succ=p;
Cu toate ca utilizarea explicita a pointerului this se intalneste mai rar, el poate fi mentionat in cadrul unei functii membre.
Exemplu:
# include<stdio> # include<iostream> # include<string> # include<conio> class student
{ public: char nume[30]; int Scrie(char*n,long t=0);
void Afis( );
void Afis1( );
long Telefon( );
long tel; };
// mai multe implementari in aceeasi clasa - caracteristica a functiilor membre void student::Afis( )
{ for(int k=0;k<35;k++) printf("*"; printf("\n"; printf("Numele studentului:%s\n",nume);
printf("Telefonul:%ld\n",tel);
}
void student::Afis1( )
{
for(int k=0;k<35>nume);
printf("\n";
printf("Telefonul:%ld\n",this->tel);
}
// In aceasta situatie, utilizarea explicita a pointerului this, nu este necesara
long student::Telefon( ){return tel;}
// functie de acces care are rolul doar de a returna valoarea unei date
int student::Scrie(char*n,long t)
{
clrscr( );
strcpy(nume,n);
tel=t;
return 1;
}
char*Nume="Vlad Stefanita";
long Telefon=198764;
void main( )
{
student s;
s.Scrie(Nume,Telefon);
s.Afis( );printf("\n";
s.Afis1( );
}
Exista situatii in care este obligatorie utilizarea pointerului this. De exemplu, atunci cand se doreste ca unei functii membre a unui obiect sa i se transmita adresa obiectului respectiv (vezi implementarea unei stive).
De retinut faptul, ca o functie de acces are scopul de a verifica continutul unei date, inainte ca aceasta sa fie, eventual, modificata. Modificarea unor date private este permisa numai prin intermediul functiilor membre.
Aplicatie:
Sa se implementeze tipul abstract complex pentru calculul sumei a doua numere complexe.
#include <iostream> #include <conio> class complex
{ int re[10]; int im[10];
public: int cit(void); void afis(); int sum_1(void); int sum_2(void); };
int complex::cit(void)
{
for(int i=1;i<=2;i++){
cout<<"\n Dati partea reala a numarului complex_1:";
cin>>re[i];
cout<<"\n Dati partea imaginara a numarului complex_2:"; cin>>im[i]; } return 1;
}
int complex::sum_1(void)
{
int s1=0;
for(int i=1;i<=2;i++) s1+=re[i];
return s1;
}
int complex::sum_2(void)
{
int s2=0;
for(int i=1;i<=2;i++) s2+=im[i];
return s2;
}
void complex::afis()
{
cout<<"\n Suma numerelor complexe:" <<sum_1()<<"+i*"<<sum_2();
}
void main()
{
complex c;
clrscr();
c.cit();
c.afis();
}
Aplicatie:
Sa se implementeze clasa student in care sa se foloseasca urmatoarele functii membre:
o functie prin care sa se citeasca numele, prenumele si notele obtinute la o
sesiune de examene de catre un student;
o functie pentru afisare;
o functie pentru calculul mediei de promovare.
#include <iostream>
#include <conio> #include <math> class student{ char nume[20];
char prenume[20];
int nota[5];
public:
int id_student(void);
void afis(void);
double media(void);
};
int student::id_student(void)
{
cout<<"\n Nume student:";
cin>>nume;
cout<<"\n Prenume student:";
cin>>prenume;
for (int k=1;k<=5;k++)
{
cout<<"Nota"<<k<<"\n";
cin>>nota[k];}
return 1;
}
void student::afis(void)
{
cout<<"\n Nume student:";
cout<<nume;
cout<<"\n Prenume student:";
cout<<prenume<<"\n";
for (int k=1;k<=5;k++)
{
cout<<"Nota"<<k<<"\n";
cout<<nota[k];
cout<<"\n";
}
cout<<"\n Media:";
cout<<media();
}
double student::media(void)
{
double m=0.0;
for (int k=1;k<=5;k++)
if(nota[k]<5){cout<<"\n Student restantier";
cout<<"\n Nu se calculeaza media!";
return 0;
}
else m = m+nota[k];
if (nota[k]<5)return 0;
else return m/5;
}
void main (void)
{
student s;
clrscr();
s.id_student();
s.afis();
getch();
}
Aplicatie:
Sa se scrie un program C++ pentru calculul ariei si perimetrului unui dreptunghi folosind doua clase (Punct, Dreptunghi).
#include <iostream>
#include <conio>
class Punct{
float x,y;
public:
void init(float, float);
float df_x(Punct&;
float df_y(Punct&;
};
void Punct::init(float a, float b) {x=a;y=b;}
float Punct:: df_x(Punct &a)
{
float d;
d=a.x-x;
return d;
}
float Punct:: df_y(Punct &a)
{
float d;
d=y-a.y;
return d;
}
class Dreptunghi
{
Punct p_st_sus,p_dr_jos;
public:
void init(float,float,float, float);
float Aria(void);
float Perimetru(void);
};
void Dreptunghi::init(float xs,float ys,float xd, float yd){
p_st_sus.init(xs,ys);
p_dr_jos.init(xd,yd);
}
float Dreptunghi::Aria(void)
{
float l,L,a;
l=p_st_sus.df_y(p_dr_jos);
L=p_st_sus.df_x(p_dr_jos);
a=l*L;
return a;
}
float Dreptunghi::Perimetru(void)
{
float l,L,p;
l=p_st_sus.df_y(p_dr_jos);
L=p_st_sus.df_x(p_dr_jos);
p=2*(l+L);
return p;
}
void main(void)
{
Dreptunghi dr;
float arie,perim;
dr.init(1,20,15,1);
arie=dr.Aria();
perim=dr.Perimetru();
cout<<"Aria="<<arie<<"\n Perimetru = "<<perim<<"\n";
getch();
}
|
|
