Scrigroup - Documente si articole

Username / Parola inexistente      

Home Documente Upload Resurse Alte limbi doc  

CATEGORII DOCUMENTE





AccessAdobe photoshopAlgoritmiAutocadBaze de dateC
C sharpCalculatoareCorel drawDot netExcelFox pro
FrontpageHardwareHtmlInternetJavaLinux
MatlabMs dosPascalPhpPower pointRetele calculatoare
SqlTutorialsWebdesignWindowsWordXml

Functiile destructor

calculatoare

+ Font mai mare | - Font mai mic







DOCUMENTE SIMILARE

Trimite pe Messenger
Sistemul de fisiere
Sistemul informational - componenta a sistemului de management
Proiectarea registrelor si a latchurilor
Proceduri. Programe.
DESPRE APLICATIILE INFORMATICII IN MEDICINA
Grila - INFORMATICA DE GESTIUNE
Urmarirea desfasurarii proiectului - Microsoft Project
SISTEMUL INFORMATIC, INSTRUMENT AL MANAGEMENTULUI ORGANIZATIILOR ECONOMICO-SOCIALE
Notiuni de HTML
MICROSOFT OFFICE XP PRO

Functiile destructor

            Dupa cum s-a precizat, daca intr-o clasa se declara si se descrie o functie constructor, atunci cand se ceeaza o instanta obiect a acelei clase, functia constructor se executa automat determinand initializarea diversilor membri ai clasei respective. De asemenea, la declararea unei instante obiect se aloca memoria necesara acesteia. In mod asemanator, limbajul C++ permite definirea unei functii destructor care se va executa automat cand se distrugea instanta obiect a unei clase. In mod uzual, functia destructor se executa automat in urmatoarele doua situatii: in cazul in care in program se intalneste operatorul delete in vederea eliberarii memoriei anterior alocata instantei obiect sau in cazul terminarii efective a programului. Mai jos, sunt date prototipurile generale ale unei functii constructor si functiei destructor asociata.



 // declararea prototipului functiei constructor

nume_functie_constructor (parametrii_formali_ai_functiei_constructor);

// declararea prototipului functiei destructor

~nume_functie_constructor (void);

Observatii:

            - functia destructor trebuie sa aiba acelasi nume ca functia constructor asociata, preccedat in mod definitoriu de caracterul tilda(~);

- functia destructor nu accepta parametri formali si, ca si functia constructor, nu poate returna  nicio valoare;

- utilitatea evidenta a functiilor destructor se face imperios simtita, mai ales, atunci cand clasele aloca memorie dinamica unor date membre, cum ar fi matricele, structurile si alte tipuri complexe de date. Prin functiile destructor se poate elibera memoria alocata pe parcursul executarii programului, unor date membre;

- prin functiile destructor se pot efectua multe din operatiile specifice listelor simplu si dublu inlantuite, cum arfi: stergerea sau adaugarea, unuor elemente in lizta;

- functiile destructor nu trebuie apelate si executate inaintea incheierii ciclului de existenta a instantei obiect respective, ci numai cand se asigura faptul ca instanta obiect urmeaza efectiv sa fie distrusa.

Problema 1

   Se considera o echpa de muncitori (max=20) cu structura: cod matricol (intre 1000 si 9999), nume, prenume, salariu brut, somaj, CAS (Contributia pentru Asigurari Sociale), CASS  (Contributia pentru Asigurari Sociale de Sanatate), baza de impozitare, impozitul pe salariu, retineri si rest de plata. Prin intermediul unei clase, in care a fost definita o functie constructor careia i se transmit parametri efectivi: cod matricol, nume, prenume, salariu brut si retinerile, sa se calculeze: contributia de somaj, CAS, CASS, baza de impozitare, impozitul, si restul de plata pentru toti muncitorii din echipa, condusi de seful de achipa aflat in capul listei, pentru seful de sectie si inginerul sef. Concomitent cu functia constructor adecvata, se va defini si functia destructor asociata, care, la terminarea programului, sa afiseze mesajele cu privire la distrugerea instantelor declarate in functia principala main().

#include<iostream.h>

#include<iomanip.h>

#define nmax 20

int i;

// declararea structurii unui angajat

struct tipangajat

;

// declararea procentelor de somaj, CAS si CASS

double psomaj=1;

double pcas=9.5;

double pcass=6.5;

// declararea clasei salarii

class salarii

;

 // descrierea functiei destructor

 ~salarii (void)

 

  if(tm=='a')

 

  if(tm=='s')

 

 };

 // declararea vectorului cu structurile angajatilor

 struct tipangajat statplata[nmax];

 char tm;

 // descrierea functiei de calcul al salariilor

 void calculeaza_statplata(int n)

 

 };

 // descrierea functiei de afisare stat de plata

 void afiseaza_statplata(int n)

 

 };

};

void main(void)

  while ((n<1)||(n>nmax));

  // citirea datelor unui angajat

  for(i=0;i<n;i++)

 

  cout<<'n==================================';

  // creearea instantei angajat a clasei salarii

  salarii angajat(p,n,'m');

  cout<<'n stat de plata muncitori';

  cout<<'n==================================';

  // apelarea functiei ptr calcularea salariilor angajatilor

  angajat.calculeaza_statplata(n);

  // afisarea salariilor angajatilor

  angajat.afiseaza_statplata(n);

  cout<<'n ==================================';

  cout<<'n cod matricol sef sectie (1000-9999):';

  cin>>psefsectie[0].matricol;

  cout<<'n nume sef sectie:';

  cin>>psefsectie[0].nume;

  cout<<'n prenume sef sectie:';

  cin>>psefsectie[0].prenume;

  cout<<'n salariu brut sef sectie :';

  cin>>psefsectie[0].brut;

  cout<<'n retineri sef sectie:';

  cin>>psefsectie[0].retineri;

  cout<<'n ===================================';

  // creearea instantei sefsectie a clasei salarii

  salarii sefsectie(psefsectie,1,'a');

  cout<<'n stat de plata sef de sectie ';

  cout<<'n==================================';

  // apelarea functiei ptr calcularea salariului sefului de sectie

  sefsectie.calculeaza_statplata(1);

  // afisarea salariului sefului de sectie

  sefsectie.afiseaza_statplata(1);

  cout<<'n ===================================';

  cout<<'n cod matricol ing. sef (1000-9999):';

  cin>>pingsef[0].matricol;

  cout<<'n nume ing. sef:';

  cin>>pingsef[0].nume;

  cout<<'n prenume ing. sef:';

  cin>>pingsef[0].prenume;

  cout<<'n salariu brut ing. sef :';

  cin>>pingsef[0].brut;

  cout<<'n retineri ing. sef:';

  cin>>pingsef[0].retineri;

  cout<<'n ===================================';

  // creearea instantei ingsef a clasei salarii

  salarii ingsef(pingsef,1,'s');

  cout<<'n stat de plata inginer sef ';

  cout<<'n==================================';

  // apelarea functiei ptr calcularea salariului ing sef

  ingsef.calculeaza_statplata(1);

  // afisarea salariului ing sef

  ingsef.afiseaza_statplata(1);

  cout<<'n ===================================';

  cout<<'n continuati salarizarea?(d/n):';

  cin>>r;

  // la terminarea programului, prin functia destructor definita

  // se distrug instantele creeate cu mesajele predeclarate

 }

}

            In urma executarii programului de mai sus, s-au obtinut rezultatele urmatoare, punandu-se in evidenta declararea, descrierea si utilizarea functiei destructor pentru distrugerea instantelor create in functia main(), cu afisarea mesajelor de rigoare, transmiterea si utilizarea structurilor, ca parametri formali in functia constructor.

 numarul de angajati (1<=n<=20):2

 cod matricol 0 (1000-9999):100

 nume :pop

 prenume :ion

 salariu brut :3000

 retineri :1000

 cod matricol 1 (1000-9999):200

 nume :stanescu

 prenume :stefan

 salariu brut :2000

 retineri :850

 ====================================================

 stat de plata muncitori

 ====================================================

 matricol:100

 nume:pop

 prenume:ion

 salariu brut:3000.00

 somaj:30.00

 CAS:285.00

 CASS:195.00

 impozit:398.40

 retineri:1000.00

 rest plata:1091.60

 matricol:200

 nume:stanescu

 prenume:stefan

 salariu brut:2000.00

 somaj:20.00

 CAS:190.00

 CASS:130.00

 impozit:265.60

 retineri:850.00

 rest plata:544.40

 ====================================================

 cod matricol sef sectie (1000-9999):300

 nume sef sectie:popescu

 prenume sef sectie:sandu

 salariu brut sef sectie :4000

 retineri sef sectie:1200

 ====================================================

 stat de plata sef de sectie

 ====================================================

 matricol:300

 nume:popescu

 prenume:sandu

 salariu brut:4000.00

 somaj:40.00

 CAS:380.00

 CASS:260.00

 impozit:531.20

 retineri:1200.00

 rest plata:1588.80

 ========================================

 cod matricol ing. sef (1000-9999):500

 nume ing. sef:stabu

 prenume ing. sef:spiridon

 salariu brut ing. sef :5000

 retineri ing. sef:2000

 ========================================

 stat de plata inginer sef

 ========================================

 matricol:500

 nume:stabu

 prenume:spiridon

 salariu brut:5000.00

 somaj:50.00

 CAS:475.00

 CASS:325.00

 impozit:664.00

 retineri:2000.00

 rest plata:1486.00

 ========================================

 continuati salarizarea?(d/n):n

 s-a distrus instanta inginerului sef stabu spiridon

 s-a distrus instanta sefului de sectie popescu sandu

 s-a distrus instanta muncitorilor cu seful de achipa pop ion

            Functiile destructor sunt utilizate si pentru distrugerea instantelor obiectelor care gestioneaza diverse stive de date, ocazie cu care se si elibereaza memoria alocata unei stive, prin functia constructor.



Problema 2

Se considera o stiva de containere cu caracteristicile:cod container, un numar cuprins intre 1 si 99,  continut, un camp alfanumeric de 20 caractere, data ambalarii (zi, luna si an) si greutatea in kg. Sa se simuleze activitatile de stivuire si de incarcare intr-un mijloc de transport a containerelor din stiva prin intermediul unei clase stivuire_incarcare, care contine: o functie constructor utilizata pentru initializarea stivei (alocarea spatiului de memorie adecvat), o functie destructor necesata distrugerii instantelor obiectelor folosite, o functie de depunere container in stiva si o functie de extragere container din stiva.

#include<iostream.h>

#include<string.h>

#include<malloc.h>

#include<stdlib.h>

#define nmax 6

int nrob=2;

struct tipdata

;

struct tipstiva

;

class stivuire_incarcare

;

// descrierea functiei constructor care  aloca spatiul pentru stiva

stivuire_incarcare::stivuire_incarcare(void)

}

// descrierea functie destructor

stivuire_incarcare::~stivuire_incarcare (void)

// descrierea functiei depune_in_stiva()

int stivuire_incarcare::depune_in_stiva(struct tipstiva *ptrstructura)

 *ptrcontainer=*ptrstructura;

 *stivuire_incarcare::varfstiva=*ptrcontainer;

 cout<<'n varf stiva ='<<stivuire_incarcare::varfstiva;

 cout<<'n cod container ='<<stivuire_incarcare::varfstiva->cc;

 stivuire_incarcare::varfstiva++;;

 return 1;

}

/* descrierea functiei de extragere din stiva */

int stivuire_incarcare::extrage_din_stiva(struct tipstiva *ptrstructura)

 stivuire_incarcare::varfstiva--;

 *ptrstructura=*stivuire_incarcare::varfstiva;

 ptrstructura=stivuire_incarcare::varfstiva;

 return 1;

}

void main(void)

 do

 

 while((n<1)||(n>nmax));

 while(!terminat)

 

    else

      cout<<'n depasirea capacitatii de depozitare';                 

      break;

   case 's':

     if(k>=1)

     

        if(k%2)

        

        else

        

        k--;

      }

     else

       cout<<'n nu mai sunt containere depozitate';

       break;

   case 't':

       terminat=1;

       break;

   default: 

       cout<<'n operatie gresit selectata';

  }

 }

}

            Rezultatele executiei programului de mai sus, sunt afisate in continuare, punandu-se in evidenta urmatoarele: initializarea si alocarea memoriei pentru o stiva de structuri, depunerea adreselor structurilor intr-o stiva si a structurilor aferente la adresle specificate in stiva, extragerea adreselor structurilor din stiva si a structurilor corespunzatoare de la aceste adrese precum si distrugerea instantelor celor doua obiecte create in program dupa terminarea folosirii acestora.

 initializarea stivei de containere

 initializarea stivei de containere

 numarul maxim de containere, n(1<=n<=6)=4

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:a

 cod container:100

 continut container:ciment

 ziua ambalarii:11

 luna ambalarii:11

 anul ambalarii:2005

 greutate container:150

 varf stiva =0x00790610

 cod container =100

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:a

 cod container:200

 continut container:var

 ziua ambalarii:21

 luna ambalarii:11

 anul ambalarii:2005

 greutate container:400

 varf stiva =0x007904F0

 cod container =200

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:a

 cod container:300

 continut container:suruburi

 ziua ambalarii:11

 luna ambalarii:10

 anul ambalarii:2005

 greutate container:125

 varf stiva =0x00790638

 cod container =300

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:a

 cod container:400

 continut container:saibe

 ziua ambalarii:07

 luna ambalarii:09

 anul ambalarii:2005

 greutate container:175

 varf stiva =0x00790518

 cod container =400

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:r

 operatie gresit selectata

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:d

 operatie gresit selectata

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:a

 depasirea capacitatii de depozitare

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:s

 s-a extras containerul obiectului 2:

 ===================================:

 cod container :400

 continut container :saibe

 data containerului :07/09/2005

 greutate container :175

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:s

 s-a extras containerul obiectului 1:

 =======================================:

 cod container :300

 continut container :suruburi

 data containerului :11/10/2005

 greutate container :125

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:s

 s-a extras containerul obiectului 2:

 ===================================:

 cod container :200

 continut container :var

 data containerului :21/i1/2005

 greutate container :400

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:s

 s-a extras containerul obiectului 1:

 =======================================:

 cod container :100

 continut container :ciment

 data containerului :11/11/2005

 greutate container :150

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 Alegeti operatia dorita:s

 nu mai sunt containere depozitate

 a - asezare container in stiva

 s - scoatere container din stiva

 t - terminare program

 s-a distrus instanta obiect2

 s-a distrus instanta obiect1

 2. Proprietati ale claselor : Incapsularea, mostenirea si polimorfismul in Programarea Orientata pe Obiecte (POO)

2. 1. Incapsularea nu reprezinta altceva decat proprietatea claselor de obiecte de a grupa sub aceeasi structura datele si metodele aplicabile asupra datelor. In sensul programarii orientata pe obiecte, incapsularea defineste, de asemenea, modalitatea in care diversele obiecte si restul programului se pot referi la datele specifice obiectelor. Dupa cum s-a precizat  clasele  din C++ permit separarea datelor in date private si date publice. Programele utilizatorilor pot accesa si utiliza datele unui obiect, declarate private, numai prin utilizarea unor metode definite public. Separarea datelor in sectiuni de date publice si private datermina protejarea datelor fata de utilizarea lor eronata in programe. Incapsularea, desi nu am precizat-o distinct, este prezenta in toate exemplele anterioare.




2. 2. Mostenirea este o proprietate prin care o clasa de obiecte poate fi obtinuta din derivarea unei clase sau a mai multor clase anterior definite. O clasa derivata poate constitui, la randul ei, clasa de baza pentru derivarea altor clase. Cand se defineste o clasa se incepe cu caracteristicile ei generale. Definirea unei alte clase prin derivarea clasei de baza presupunea definirea caracteristicilor specifice acesteia in raport cu cea de baza. Daca am defini clasa de baza Cai aceasta ar trebui sa contina caracteristicile comune ale tuturor raselor de cai : nume, origine, inaltime, greutate si culoare. Urmatorul nivel de declarare a  tipului de clase de cai poate fi mai detaliat. De exemplu, clasa CaiCuPete si clasa CaiFaraPete, ar trebui sa mosteneasca toate caracteristicile comune care au fost definite la clasa de baza Cai alaturi de caracteristicile specifice claselor derivate cum ar fi : la clasa CaiCuPete :lungimea parului, culoarea petelor, cal de cursa iar la clasa CaiFaraPete : lungimea parului, tip de utilizare (de tractiune, de curse, etc). Nivelurile de derivare ale claselor pot creste ca un arbore genealogic.

Text Box:       Clasa CaiCuPete
-lungimea parului,
-culoare pete, 
-semne particulare


        fulger

 

        roib

 

        murg

 
                                                                                                                       

                       

Structura arborescenta a mostenirii clasei Cai

                                               Structura arborescenta a claselor derivate

            Conceptul de mostenire este deosebit de important in programarea obiectuala. Posibilitatea de a crea o arborescenta de clase, de la cea mai generala la cea mai specifica, permite un control mai bun al programelor, permitand, totodata, lisibilitatea facila a programelor  de catre utilizatorii textelor sursa sau dezvoltatorii de programme. Mostenirea si proprietatile acesteia reprezinta adevarata forta in programarea obiectuala in C++.

 2. 2. 1. Clasele de baza si derivate

Fundamentul de baza al conceptului de mostenire este relatia dintre clasele de baza si clasele derivate din acestea. Atunci cand se construieste o noua clasa, numita derivata, pornind de la una deja existenta, numita clasa de baza,  caracteristicile clasei derivate cuprinde datele si metodele, precum si accesul lor, privat sau public, al clasei de baza. Clasa de baza este cunoscuta ca o clasa originara ale carei caracteristici se mostenesc la toate clasele derivate din aceasta. Clasa derivata este clasa creata intr-un program pornind de la o clasa de baza. Prin urmare dintr-o clasa de baza pot fi obtinute prin derivare mai multe clase distincte. De asemenea exista posibiliutatea construirii unei clase derivate pornind de la mai multe clase de baza


                                                                                                                   Clasa de baza


 


                                                                                                                     

                Clasa derivata


           

                                   Detalierea unui exemplu simplu de mostenire    

                                          Detalierea unui exemplu simplu de mostenire

Problema 3

            Sa se citeasca de la tastatura informatiile specifice cartilor dintr-o librarie: denumire carte, numele autorului, prenumele autorului, numarul de pagini si pretul. Prin intermediul unei clase de baza numita carte, care precizeaza proprietatea, titlul cartii si o clasa derivata numita FisaLibrarie care precizeaza celelalte date despre o carte, proprietatile (numele autorului, prenumele autor, editura, numarul de pagini si pretul) si metodele de prelucrare (initializarea si afisarea datelor cartilor din librarie), sa se afiseze cartile din librarie cu toate proprietatile lor.

// definirea clasei carte

#include<iostream.h>

#include<string.h>

#include<stdio.h>

// definirea clasei de baza carte

class carte

;

    void afisaza_nume()

      ;    

  private:

     char nume[40];

 };

// definirea clasei derivate FisaLibrarie

class FisaLibrarie: public carte

 ;

   void afisaza_Libraria()

     ; 

  private:

     char autor1[40];

     char autor2[40];

     char editura[40];

     int nrpag;

     double pret;

 };

void main()

 

  }

            Rezultatele executiei programului anterior sunt redate mai jos, care precizeaza modul cum se obtine o clasa derivata dintr-o clasa de baza, punandu-se in evidenta proprietatea de baza a unei clase derivate de a mosteni datele si metodele clasei de baza.

 denumirea cartii:Visual Basic 6. Baze de date

 numele autorului:Winemiller

 prenumele autorului:Eric

 editura:Teora

 nr. pagini:895

 pret:59

         Lista cartilor din librarie:

 ====================================

 Titlul cartii:Visual Basic 6. Baze de date

 numele autorului: Winemiller

 prenumele autorului: Eric

 editura: Teora

 nr de pagini: 895

 pretul cartii: 59

 ====================================

 continuati?(d/n):d

 denumirea cartii:JAWA in 21 days

 numele autorului:Lemay

 prenumele autorului:Laura

 nr. pagini:527

 pret:49

         Lista cartilor din librarie:

 ====================================

 Titlul cartii:JAWA in 21 days

 numele autorului: Lemay

 prenumele autorului: Laura

 editura: The Macmillan Information SuperLibrary

 nr de pagini: 527

 pretul cartii: 49

 ====================================

 continuati?(d/n):n

            In programul de mai sus, din clasa de baza carte, s-a obtinut clasa FisaLibrarie care, prin intermediul liniei de definire class FisaLibrarie: public carte,  informeaza compilatorul ca este o clasa derivata din clasa de baza carte. Restul din declaratia clasei derivate este asemanator cu cele invatate la descrierea claselor, cu exceptia functiei constructor care contine o apelare a functiei constructor a clasei de baza carte :

FisaLibrarie(char *nume, char *aut1, char *aut2, char *ed, int *np, double *p):carte(nume)

     ;

Dupa cum se observa, atunci cand programul creaza o noua instanta a clasei derivate FisaLibrarie si apeleaza functia constructor , FisaLibrarie, mai intai va apela functia constructor a clasei de baza carte(nume) dupa care va apela si executa corpul propriei functii constructor. Neprecizarea functiei constructor a clasei de baza, in declararea functiei constructor a clasei derivate, va antrena un mesaj de eroare, chiar in timpul compilarii.

           

Utilizarea membrilor de tip protected in clasele derivate

Clasele derivate pot accesa membrii protejati (declarati protected) ai claselor de baza. Cand se creaza o clasa trebuie sa se precizeze care membri vor fi publici, privati sau protejati si sa se tina seama ca orice clasa derivata din aceasta sa o poata utiliza. Daca o clasa nu va fi utilizata niciodata ca o clasa de baza pentru alte clase derivate  se vor utiliza membri privati in locul celor protejati, iar daca clasa va fi utilizata, ulterior, ca o clasa de baza, atunci utilizarea membrilor protejati devine imperioasa in economisirea timpilor de programare

Problema 4

            Sa se citeasca de la tastatura informatiile specifice cartilor dintr-o librarie: denumire carte, numele autorului, prenumele autorului, numarul de pagini si pretul, prin intermediul unei clase de baza numita carte, care precizeaza proprietatea, titlul cartii, ca membru public, numarul de pagini si pretul ca membri protejati si o clasa derivata numita FisaLibrarie care precizeaza celelalte date despre o carte, proprietatile : numele autorului, prenumele autor, editura ca membri privati si metodele de prelucrare (initializarea si afisarea datelor cartilor din librarie)

// definirea clasei carte

#include<iostream.h>

#include<string.h>

// definirea clasei de baza carte

class carte

;

    void afisaza_nume()

      ;   

  protected :

    int nrpag ;

    float pret ;

    void afisaza_nrpag(void)

     

    void afisaza_pret(void)

     



  private:

     char nume[40];

 };

// definirea clasei derivate FisaLibrarie

class FisaLibrarie: public carte

 ;

   void afisaza_Libraria()

     ; 

  private:

     char autor1[40];

     char autor2[40];

     char editura[40];

};

void main()

 

  }

            Rezultatele acestui program se obtin in aceeasi maniera ca in programul anterior, cu deosebirea ca se folosesc, in clasa derivata, membri de tip protected.

            In programul de mai sus, clasa carte declara ca membri protejati numarul de pagini (nrpag), pretul cartii (pret) si functiile afisaza_nrpag si afisaza_pret fapt ce permite accesarea acestora din clasa derivata FisaLibrarie : citirea datelor nrpag si pret si apelarea pentru executie a functiilor afisaza_nrpag si afisaza_pret.

 

2. 2. 2.  Mosteniri publice, private si protejate

Mostenirea publica. Declararea publica a unei clase de baza intr-o clasa derivata

O clasa derivata dintr-o clasa de baza poate fi facuta printr-o derivare publica, caz in care clasa derivata poate avea acces direct la membri clasei de baza, acest lucru incalcand regulile incapsularii, lucru care trebuie evitat in programarea obiectuala. Derivarea privata  permite transformarea tuturor membrilor clasei de baza in membri privati.

Problema 5

Sa se deriveze  de tip public o clasa de baza  pentru a se avea acces, din clasa derivata, la toti membri clasei de baza. In clasa de baza se vor declara pubice datele: a,b si data si functia constructor care citeste efectiv valorile a si b. In clasa derivata de tip public se va descrie functia constructor care afiseaza suma si produsul numerelor a si b iar in functia principala main() prin intermediul unui obiect al clasei derivate se va atribui datei publice data din clasa de baza suma patratelor celor doua numere a si b, afisandu-se datele a, b si data precum si diferenta si catul datelor a si b.

#include <iostream.h>

class ClasaDeBaza

  ;

       int data,a,b;

   };

class ClasaDerivata:public ClasaDeBaza

   ;

   };

void main(void)

 

  }

            Executia programului pune in evidenta facilitatea declararii punlice a unei clase de baza intr-o clasa derivata, asa cum se poate observa din rezultatele obtinute mai jos:

 Constructorul clasei de baza

 dati nr intregi a,b=50 25

 Constructorul clasei derivate

 (50)+(25)=75

 (50)*(25)=1250

 (50)-(25)=25

 (50)/(25)=2

 data=(50)*(50)+(25)*(25)=3125

 continuati?(d/n):d

 Constructorul clasei de baza

 dati nr intregi a,b=-90 45

 Constructorul clasei derivate

 (-90)+(45)=-45

 (-90)*(45)=-4050

 (-90)-(45)=-135

 (-90)/(45)=-2 

 data=(-90)*(-90)+(45)*(45)=10125

 continuati?(d/n):d

 Constructorul clasei de baza

 dati nr intregi a,b=-120 -30

 Constructorul clasei derivate

 (-120)+(-30)=-150

 (-120)*(-30)=3600

 (-120)-(-30)=-90

 (-120)/(-30)=4

 data=(-120)*(-120)+(-30)*(-30)=15300

 continuati?(d/n):n

Daca clasa derivata, ar mosteni clasa de baza in mod privat, atunci apelarea membrilor publici ai clasei de baza ar declansa, in timpul compilarii erori specifice. Pentru edificare, in programul de mai sus, se poate schimba linia de definire a clasei derivate class ClasaDerivata:public ClasaDeBaza  cu class ClasaDerivata: private ClasaDeBaza, urmarindu-se erorile de compilare semnalate.

2. 2. 3. Mostenirea protejata. Declararea protejata a unei clase de baza intr-o clasa derivata

            Pentru a preveni accesul altor parti ale programului la anumiti membri ai clasei de baza, dar permitand claselor mostenitoare accesul la membri disponibili ai clasei de baza, acestia se pot declara de tip protected. De asemenea exista posibilitatea mostenirii unei intregi clase de baza ca protected, acest lucru permitand clasei derivate sa utilizeze toti membri publici si protejati ai clasei de baza ca membri protejati ai sai.

Problema 6

Sa se deriveze  de tip protected o clasa de baza  pentru a se avea acces, din clasa derivata, la toti membri clasei de baza. In clasa de baza se vor declara protected datele x si y, functia de setare a variabilelor x si y, setarexy() si functia de afisare a variabilelor setate x si y, afisarexy(). In clasa derivata de tip protected se vor declara privat variabilele va, vb si sumaxy, public functia de calcul a sumei x+y, calculsuma(), dupa ce s-a apelat functia setarexy() pentru atribuirea valorilor va si vb citite in functia de calcul, si functia afisaza_x_y_sumaxy() care apeleaza pentru afisare functia publica afisazaxy() din clasa de baza, iar in functia principala main(), prin intermediul unui obiect al clasei derivate se vor apela functiile calculsuma() si afisaza_x_y_sumaxy() prin intermediul uni obiect al clasei derivate, adecvat definit.

#include <iostream.h>

class ClasaDeBaza

 

       void afisazaxy()

         

  };

class ClasaDerivata:protected ClasaDeBaza

  

      void afisaza_x_y_sumaxy()

     

   };         

void main(void)

}         

            Rezultatele afisate de program pun in evidenta cum o clasa derivata de tip protected dintr-o clasa de baza, utilizeaza prin mostenire membrii clasei de baza

 apelarea in main() a functiei calculsuma()

 citirea valorilor va si vb in clasa derivata 

 si apelarea functiei setarexy()

 va, vb=78 98

 atribuirea valorilor a si b,

 citite in clasa derivata, variabilelor x si y

 apelarea in main() a functiei afisaza_x_y_sumaxy()

 afisarea valorilor x si y si a sumei lor in clasa

 derivata prin functia afisazaxy()

 afisarea valorilor x si y, atribuite prin functia setarexxy()

 x=78 y=98

 (78)+(98)=176

 continuati?(d/n):

 apelarea in main() a functiei calculsuma()

 citirea valorilor va si vb in clasa derivata 

 si apelarea functiei setarexy()

 va, vb=-98 45

 atribuirea valorilor a si b,

 citite in clasa derivata, variabilelor x si y

 apelarea in main() a functiei afisaza_x_y_sumaxy()

 afisarea valorilor x si y si a sumei lor in clasa

 derivata prin functia afisazaxy()

 afisarea valorilor x si y, atribuite prin functia setarexxy()

 x=-98 y=45

 (-98)+(45)=-53

 continuati?(d/n):d

 apelarea in main() a functiei calculsuma()

 citirea valorilor va si vb in clasa derivata 

 si apelarea functiei setarexy()

 va, vb=-35 -77

 atribuirea valorilor a si b,

 citite in clasa derivata, variabilelor x si y

 apelarea in main() a functiei afisaza_x_y_sumaxy()

 afisarea valorilor x si y si a sumei lor in clasa

 derivata prin functia afisazaxy()

 afisarea valorilor x si y, atribuite prin functia setarexxy()

 x=-35 y=-77

(-35)+(-77)=-112

 continuati?(d/n):n

            Dupa cum se constata, in programul de mai sus, clasa ClasaDerivata, in derivarea clasei de baza, foloseste cuvantul cheie protected. Acest lucru determina transformarea tuturor membrilor clasei ClasaDeBaza in membri privati, in contextul clasei ClasaDerivata. In aceste conditii orice incercare a programului de a accesa  un membru privat, cum ar fi setarexy() sau afisazaxy(), ar conduce la erori de compilare deoarece acesti membri sunt incapsulati si protejati in cadrul clasei ClasaDerivata. Din aceste motive singurele obiecte ce pot accesa functiile mostenite de la clasa de baza sunt functii de interfata sau clase care se deriveaza din clasa ClasaDerivata.

Probleme propuse

1.Sa se realizeze o ierarhie de clase care descrie multimea elementelor din plan intalnite in geometrie. Se considera clasa de baza CPunct , din ea se deriveaza clasa CDreapta , clasa CCerc , clasa CDreptunghi , clasa CPatrat .Pentru clasele CCerc,CDreptunghi si CPatrat sa se implementeze o functie de calcul a ariei si o functie pentru calculul perimetrului.

2.Sa se construiasca o ierarhie de clase care descrie rasele de caini.Se considera clasa de baza Caine , din ea se deriveaza clasa CaineCuPete , clasa CaineFaraPete . Despre un caine se cunosc : numele, inaltime, greutate, varsta, culoare.Despre cainii cu pete se stie si numarul de pete. Sa se defineasca pentru fiecare clasa o functie de citire a datelor, respectiv una de afisare.


3.Sa se construiasca o ierarhie de clase care sa simuleze functionarea unei retele de calculatoare. Reteaua admite maxim 10 utilizatori si furnizeaza protectie prin parola si functii pentru conectare si deconectare. Reteaua este gestionata de un administrator.Pentru fiecare utilizator se cunoaste parola si numele. Administratorul este la randul sau tot un utilizator care are anumite facilitati in plus : poate vizualiza toti utilizatorii retelei, poate deconecta unul sau mai multi utilizatori , poate schimba setul de comenzi functionale.
Sa se realizeze clasa CRetea care va avea un nume, un numar de maxim 11 utilizatori din care unul singur poate fi administrator.

4.Sa se realizeze o ierarhie de clase care descrie habitatul animalelor dintr-o rezervatie naturala. In rezervatie pot fi intalnite urmatoarele animale :iepuri,ursi,caprioare,vulpi si lei.Unele dintre animale sunt ierbivore,alte carnivore sau chiar ierbivore si carnivore.Ierarhia de clase va avea clasa de baza CAnimal, clasa abstracta, din care se vor deriva doua clase : CAnimalIerbivor si CAnimalCarnivor. Pentru fiecare tip de animal vom avea o clasa corespunzatoare care se va extinde din una din clase de mai sus, sau din ambele, corespunzator modului de hranire a animalului.
Despre un animal se cunosc urmatoarele informatii comune : nume, data aducerii,greutate,hrana preferata, cantitate pe zi. In plus despre iepure se cunoaste suprafata minima pe care poate trai;despre vulpe - temperatura maxima de trai, tip (polara, indigena); despre leu - temperatura minima suportata, tara de provenienta;despre urs - perioada de hibernare; despre caprioara - numarul de pui. Sa se construiasca o clasa CRezervatie care va contine o multime de animale.Sa se populeze rezervatia.

5.Se prezinta in continuare descrierea unei ierarhii de clase:
Clasele sociale din istorie pot fi caracterizate prin urmatoarele elemente definitorii:
- sclav = nume, nume stapin
- stapin = nume, numar de sclavi
- iobag = nume, nume stapin, venit anual
- feudal = nume, suprafata de pamint detinuta, titlu
- proletar = nume, salariu lunar
- capitalist = nume, numar de fabrici detinute
O 'carte de istorie' poate fi considerata ca o 'lista' de astfel de categorii/persoane.Fiecare clasa sociala are propriul 'salut'. Sa se afiseze saluturile tuturor persoanelor dintr-o 'carte de istorie' de la un moment dat.
Pentru aceasta ierarhie se cere:
1. Sa se implementeze aceasta ierarhie folosind tehnica OOP a claselor abstracte (care inglobeaza tot ceea ce este comun intr-o ierahie) si tehnica metodelor virtuale: toate functiile care se pot modifica pe nivelele 'inferioare' ale ierarhiei sint virtuale.
2. Fiecarei clase sa i se ofere constructori, destructori si functii specifice, corespunzatoare.
3. Prelucrarea obiectelor din aceasta ierarhie in mod uniform se poate face prin tehnica 'listelor eterogene': intr-o structura tip lista (tablou, lista simplu/dublu inlantuita, arbore,) se pastreaza pointeri la obiectul abstract cel mai 'inalt' din ierarhie si prin regulile de compatibilitate dintre clase in acei pointeri se pot 'agata' orice fel de obiecte din ierarhie. Sa se implementeze aceasta tehnica pentru ierarhia anterioara folosind un tablou (sau matrice) de pointeri;
4. Se vor oferi functii pentru citirea datelor caracteristice obiectelor si introducerea lor in 'lista', pentru parcurgerea listei si 'raportarea' specifica a prezentei in lista pentru fiecare obiect in parte.








Politica de confidentialitate

DISTRIBUIE DOCUMENTUL

Comentarii


Vizualizari: 607
Importanta: rank

Comenteaza documentul:

Te rugam sa te autentifici sau sa iti faci cont pentru a putea comenta

Creaza cont nou

Termeni si conditii de utilizare | Contact
© SCRIGROUP 2019 . All rights reserved

Distribuie URL

Adauga cod HTML in site