Laborator 2 - orientata pe obiecte – limbajele C++/Java Laborator nr. 2 1 Laborator 2 1....

download Laborator 2 - orientata pe obiecte – limbajele C++/Java Laborator nr. 2 1 Laborator 2 1. Constructori

of 12

  • date post

    08-Sep-2019
  • Category

    Documents

  • view

    11
  • download

    5

Embed Size (px)

Transcript of Laborator 2 - orientata pe obiecte – limbajele C++/Java Laborator nr. 2 1 Laborator 2 1....

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    1

    Laborator 2

    1. Constructori si destructori

    2. Membri statici ai claselor

    3. Funcţii membre constante

    4. Funcţii care returnează referinţe

    5. Supraîncărcarea operatorilor

    5.1. Supraîncărcarea operatorilor folosind funcţii membre

    5.2. Supraincarcarea operatorilor folosind functii prietene

    1. Constructori si destructori

    1. Definiti si implementati clasa Carte, având ca date membre: Nume, Autor, Nrpag,

    Pret, şi ca funcţii membre: citeste_carte si afiseaza_carte.

    #include

    #include

    #include

    int i = 1;

    class carte{

    public:

    char nume[40];

    char autor[40];

    int nrpag;

    double pret;

    void citeste_carte(char *numecarte, char *autorcarte, int *np, double *p);

    void afiseaza_carte();

    };

    void carte::citeste_carte(char *numecarte, char *autorcarte, int *np, double *p)

    {

    strcpy(nume, numecarte);

    strcpy(autor, autorcarte);

    nrpag = *np;

    pret = *p;

    }

    void carte::afiseaza_carte()

    {

    cout

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    2

    int main(void)

    {

    carte cartecitita;

    char c_nume[40], c_autor[40];

    int c_nrpag;

    double c_pret;

    char optiune = 'd';

    clrscr();

    while(optiune == 'd')

    {

    coutc_nume;

    coutc_autor;

    coutc_nrpag;

    coutc_pret;

    cartecitita.citeste_carte(c_nume, c_autor, &c_nrpag, &c_pret);

    cout

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    3

    int fifo::adaug(int k) //definitia functiei membru este in afara declaratiei

    { //clasei resp. si deci trebuie specificat ca apartine

    // clasei fifo prin folosirea operatorului de

    // rezolutie ::

    if(lista_plina())

    {

    tab[(prim+nrcrt)%100]=k;

    nrcrt++;

    cout

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    4

    3. Definiţi şi implementaţi clasa Cerc, având ca dată membră Raza, un constructor şi ca

    funcţii membre Aria şi Circumferinta.

    #include

    #include

    #define PI 3.14

    class cerc{

    float raza;

    public:

    cerc();

    float aria();

    float circumferinta();

    };

    cerc::cerc()

    {

    coutraza;

    }

    float cerc::aria()

    {

    return (PI*raza*raza);

    }

    float cerc::circumferinta()

    {

    return (2*PI*raza);

    }

    int main(void)

    {

    cerc c;

    clrscr();

    cout

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    5

    4. Definiţi şi implementaţi clasa Cilindru, având ca date membre Raza şi Inaltimea

    cilindrului şi ca funcţii membre: un constructor, Aria şi Volumul.

    #include

    #include

    #define PI 3.14

    class cilindru{

    float raza;

    float inaltimea;

    public:

    cilindru();

    float aria();

    float aria_totala();

    float volum();

    };

    cilindru::cilindru()

    {

    coutraza;

    coutinaltimea;

    }

    float cilindru::aria()

    {

    return (2*PI*raza*inaltimea);

    }

    float cilindru::aria_totala()

    {

    float a;

    a=aria();

    return(a+2*PI*raza*raza);

    }

    float cilindru::volum()

    {

    return (PI*raza*raza*inaltimea);

    }

    int main(void)

    {

    clrscr();

    cilindru c;

    cout

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    6

    2. Membri statici ai claselor

    În fiecare obiect, pentru datele membre nestatice se crează copii. Pentru funcţiile

    membre există o copie unică.

    Pentru datele membre statice există o singură copie care va fi partajată de către

    toate obiectele.

    Funcţiile membre statice sunt accesibile numai în fişierul în care sunt definite,

    fiind independente de obiecte (instanţele claselor).

    O funcţie statică poate fi apelată:

     ca funcţie membră a unui obiect

     independent de obiect, folosind operatorul de rezoluţie.

    Pointerul this nu poate fi folosit de către funcţia statică, deoarece nu îi este

    transmis, aşadar funcţia statică nu poate accesa decât date membre statice şi date globale.

    Clasa Data depinde de variabila statică azi. Aceasta va aparţine clasei, dar nu şi

    obiectelor clasei.

    class Data{

    int a, l, z;

    static Data azi; //data membra statica

    public:

    Data(int aa=0, int ll=0, int zz=0);

    . . .

    static void set_data_crta(int aa, int ll, int zz);

    };

    Data::Data(int aa, int ll, int zz){

    a = aa? aa : azi.a;

    l = ll? ll : azi.l;

    z = zz? Zz : azi.z;

    };

    Funcţia set_data_crta() permite modificarea datei curente, care iniţializează un

    obiect neiniţializat. La definirea unui membru static nu se mai repetă cuvântul static.

    void Data::set_implic(int a, int l, int z){

    azi = Data(a, l, z);

    };

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    7

    3. Funcţii membre constante

    Funcţiile membre care nu modifică starea obiectului se declară ca funcţii

    constante (funcţii const), punând după lista de parametri cuvântul cheie const.

    Compilatorul va sesiza orice încercare de modificare a obiectului din funcţia const.

    Funcţiile membre apelate din obiectele constante pot fi numai funcţii constante.

    Dacă funcţia membră const este definită în afara clasei, este necesar sufixul const

    în definiţie. Exemplu:

    class Data{

    int a, l, z;

    public:

    int zi()const {return z;};

    int luna()const {return l;};

    int an()const;

    };

    inline int Data::an()const{ return a;};

    Nu este posibilă declararea unei constante simbolice în interiorul unei clase.

    Astfel:

    class Vector{

    const int N=10;

    double x[N];

    . . .

    }

    nu funcţionează corect deoarece declararea clasei descrie obiectul, dar nu îl crează. Sunt

    posibile două soluţii:

    - se declară o enumerare în interiorul clasei, care furnizează la nivelul clasei nume

    simbolice pentru constante întregi :

    class Vector{

    enum{ N=10 };

    double x[N];

    . . .

    }

    - se crează o constantă statică, partajată de toate obiectele Vector

    class Vector{

    static const int N=10;

    double x[N];

    . . .

    }

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    8

    4. Funcţii care returnează referinţe

    Pentru clasa complex, am definit funcţiile care asigură accesul partea reală,

    respectiv imaginară a unui număr complex,:

    double real(){ return re; };

    double imag(){ return im; };

    Dacă am dori modificarea părţii reale a unui număr complex printr-o atribuire de

    forma:

    z.real()=5.;

    constatăm că funcţia astfel definită nu poate apărea în partea stângă a unei atribuiri (nu

    este o L-valoare). Acest neajuns se remediază impunând funcţiei să returneze o referinţă

    la obiect, adică:

    double& real(){ return re; };

    Funcţiile de actualizare a datei ad_a(), ad_l(), ad_z() nu întorc valori. Pentru

    asemenea funcţii este util să întoarcem o referinţă la obiectul actualizat, astfel încât

    operaţiile să poată fi înlănţuite de forma:

    d.ad_a(1).ad_l(1).ad_z(1);

    Funcţiile se declară cu valoare de întoarcere referinţă la Data:

    class Data{

    Data& ad_a(int);

    Data& ad_l(int);

    Data& ad_z(int);

    };

    Data& ad_a(int n){

    if(z==29 && l==2 && !bisect(a+n)){

    z=1;

    l=3;

    };

    a += n;

    return *this;

    }

    Într-o funcţie membru nestatică this este un pointer la obiectul din care s-a apelat

    funcţia membru. Nu este posibil să preluăm adresa lui this şi nici să o modificăm.

    Cele mai multe referiri la this sunt implicite. Orice referire la un membru nestatic

    din interiorul clasei foloseşte în mod implicit pe this pentru a obţine membrul din acel

    obiect.

    O clasă conţine în mod uzual: un constructor, funcţii pentru examinarea obiectelor

    (funcţii de acces), funcţii pentru manipularea obiectelor, operaţii de copiere, etc.

  • Programare orientata pe obiecte – limbajele C++/Java

    Laborator nr. 2

    9

    Probleme propuse spre rezolvare

    1. Proiectaţi şi implementaţi clasa Co