Diferență între revizuiri ale paginii „C++ POO Lab Lucrarea 4”

De la WikiLabs
Jump to navigationJump to search
 
(Nu s-au afișat 20 de versiuni intermediare efectuate de același utilizator)
Linia 4: Linia 4:
 
* Ascunderea metodelor
 
* Ascunderea metodelor
 
* Polimorfismul
 
* Polimorfismul
−
* Metode virtuale
+
* Metode virtuale și suprascrierea metodelor
−
* Suprascrierea metodelor
+
* Metode pur virtuale și clase abstracte
−
* Metode pur virtuale
 
  
−
= Moștenire =
+
= Moștenirea =
  
−
Moștenirea este mecanismul prin care o clasă preia structura (câmpuri) și comportamentul (metodele) unei alte (sau mai multor) clase, la care poate adaugă elemente specifice
+
== Introducere ==
 +
Moștenirea este mecanismul prin care o clasă preia structura (câmpurile) și comportamentul (metodele) unei alte (sau mai multor) clase, la care poate adăuga alți membri specifici.
  
−
Clasa de bază = clasa de la care se preia structura si comportamentul
+
Clasa de la care se preiau membrii se numește:
 +
* clasă de bază
 +
* superclasă
  
−
Clasa derivata = clasa care preia structura si comportamentul
+
Clasa nouă, care preia membrii de la clasa de bază se numește:
 +
* clasă derivată
 +
* clasă extinsă
 +
* subclasă
  
−
În C++, moștenirea poate fi multiplă, în sensul ca o clasa derivata poate moșteni mai multe clase de baza. Nu în toate limbajele exista acest concept (în Java de exemplu, există doar moștenire simplă)
+
În C++, moștenirea poate fi multiplă, în sensul că o clasă derivată poate moșteni mai multe clase de bază. Nu în toate limbajele există acest concept (în Java, de exemplu, există doar moștenire simplă - adică o clasă poate moșteni o singură altă clasă).
  
−
'''Avantaje''':
+
Utilitatea moștenirii în programarea orientată pe obiecte este:
 +
* reutilizarea codului existent fără modificarea acestuia;
 +
* extinderea a unei clase deja scrise, fără a fi necesară recompilarea ei;
 +
* utilizarea polimorfismului în timpul execuției, prin folosirea metodelor virtuale.
  
−
* reutilizare cod
+
== Exemplu ==
−
* extensie a unei clase deja scrise, fără a fi necesara recompilarea ei
+
<syntaxhighlight lang="C++" line highlight="29">
−
* utilizarea polimorfismului în timpul execuției, prin folosirea funcțiilor virtuale
+
#include <string>
 +
#include <cstdio>
  
−
Exemplu (pentru o clasa mostenita din clasa Animal de mai sus)
+
class Animal {
 +
    std::string mName;
 +
    std::string mColor;
 +
    int mAge;
 +
protected:
 +
    bool mHasFeathers;
  
−
<syntaxhighlight lang="C++">
 
−
class Pisica : public Animal {
 
 
public:
 
public:
−
     Pisica() : Animal() // constructorul implicit Animal este chemat explicit
+
     void makeSound() const {
−
     {  
+
        printf("Animal %s makes a sound!\n", mName.c_str());
−
      mHasFeathers = false;
+
    }
−
     } // campul mHasFeathers este protected in Animal, deci poate fi accesat de Pisica
+
 
−
}; // nu uitati de ; la sfarsitul unei clase
+
    // this is a getter method
 +
    std::string getName() const {
 +
        return mName;
 +
    }
 +
 
 +
    // this is a setter method
 +
    void setAge(int age) {
 +
        if(age > 0) {
 +
            mAge = age;
 +
        }
 +
    }
 +
};
 +
 
 +
class Cat : public Animal {
 +
    unsigned int mLives;
 +
public:
 +
     Cat() : mLives(9) {
 +
        mHasFeathers = false;
 +
     }
 +
};
 +
 
 +
int main() {
 +
    Cat cat;
 +
    cat.makeSound(); // makeSound este mostenita din clasa Animal
 +
    return 0;
 +
}
 
</syntaxhighlight>
 
</syntaxhighlight>
  
−
Relativ la specificatorul de acces declarat intre clasa derivata si clasa de baza  (class Pisica : '''public''' Animal) avem si posibilitatea de a folosi '''private''':
+
În exemplul de mai sus, clasa <code>Cat</code> preia toți membrii din clasa <code>Animal</code> și adaugă un câmp <code>mLives</code> și un constructor fără argumente. S-a introdus, de asemenea, un nou modificator de acces, <code>protected</code>, care permite accesul la membrul respectiv atât din clasa curentă cât și din orice clasă derivată din clasa curentă, dar nu și din alte clase sau funcții.
 +
 
 +
Se observă, de asemenea, că moștenirea a fost declarată publică. Există două timpuri de moșteniri:
 +
# publică
 +
# privată
 +
 
 +
Relativ la tipul de moștenire, mai jos este prezentat modul în care se preiau membrii din clasa de bază:
 
{| class="wikitable"
 
{| class="wikitable"
 
|+ Accesul asupra membrilor moșteniți
 
|+ Accesul asupra membrilor moșteniți
 
|-
 
|-
−
! Protecția in clasa de baza !! Modif de acces utilizat în lista claselor de bază !! Dreptul de acces în clasa derivată
+
! Protecția in clasa de baza !! Modificatorul de acces utilizat în lista claselor de bază !! Dreptul de acces în clasa derivată
 
|-
 
|-
 
| public || public || public
 
| public || public || public
Linia 55: Linia 98:
 
|}
 
|}
  
−
= Polimorfism =
+
<div class="regula"><font color="#ff0000">Atenție: </font>A doua diferență între <code>class</code> și <code>struct</code> este că pentru prima, moștenirea implicită este '''private''' iar pentru a doua este '''public'''.</div>
  
−
Polimorfismul '''parametric''' – mecanismul prin care putem defini o metodă cu același nume în aceași clasă, funcții care trebuie să difere prin numărul și/sau tipul parametrilor și/sau ordinea lor. Selecția funcției se realizează la '''compilare''' (legarea timpurie (early binding)). Se numește foarte des '''supraîncarcare''' pentru a evita confuzia cu polimorfismul de moștenire.
+
== Apelul constructorului superclasei ==
  
−
Polimorfismul '''de moștenire''' – mecanismul prin care o metodă din clasa de bază este redefinită cu aceiași semnatură (return value, nume, parametri) în clasele derivate. Selecția funcției se va realiza '''la execuție''' (legare întârziată == late binding). Acesta este sensul în care se folosește cel mai des, și deci sensul in care va fi interpretat cuvantul '''polimorfism''' (daca nu este specificat de ce tip este)
+
Când se instanțiază o clasă derivată, constructorul acestei clase se ocupă de inițializarea câmpurilor definite în clasa derivată. Pentru a inițializa câmpurile din clasa de bază, este necesar să apelăm constructorul ei. Prin urmare:
  
−
'''Avantaje''':
+
<div class="regula"><font color="#ff0000">Atenție: </font>Obligatoriu, constructorul unei clase derivate trebuie să apeleze constructorul clasei de bază. Dacă acest apel nu se face explicit, compilatorul va introduce un apel către constructorul clasei de bază fără argumente. Dacă acesta lipsește, apelul către constructorul clasei de bază trebuie făcut explicit, altfel se va genera o eroare de compilare.</div>
−
* clasa de baza si pointerul de tip clasa de baza pot fi scrise in codul sursa al unei biblioteci compilate cu mult timp inaintea compilarii clasei derivate (eg. ani de zile)
 
−
* pointerul de tip clasa de baza poate referi orice obiect, de orice tip clasa derivata a clasei de baza (și isi poate schimba dinamic valoarea, la execuție)
 
  
−
<syntaxhighlight lang="C++">
+
Apelul constructorului superclasei se face folosind aceeași sintaxă ca pentru inițializarea câmpurilor:
−
#include <iostream>
 
  
 +
<syntaxhighlight lang="C++" line highlight="32">
 
class Animal {
 
class Animal {
−
private:
 
 
     std::string mName;
 
     std::string mName;
 
     std::string mColor;
 
     std::string mColor;
 
     int mAge;
 
     int mAge;
 +
protected:
 +
    bool mHasFeathers;
 +
 +
public:
 +
    Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
 +
    }
 +
 +
    void makeSound() const {
 +
        printf("Animal %s makes a sound!\n", mName.c_str());
 +
    }
 +
 +
    // this is a getter method
 +
    std::string getName() const {
 +
        return mName;
 +
    }
 +
 +
    // this is a setter method
 +
    void setAge(int age) {
 +
        if(age > 0) {
 +
            mAge = age;
 +
        }
 +
    }
 +
};
  
 +
class Cat : public Animal {
 +
    unsigned int mLives;
 +
public:
 +
    Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
 +
        mHasFeathers = false;
 +
    }
 +
};
 +
</syntaxhighlight>
 +
 +
= Ascunderea metodelor =
 +
 +
În anumite situații, există nevoia ca o anumită metodă care este moștenită din clasa de bază să se comporte altfel în clasa derivată. Putem realiza acest lucru reimplementând metoda respectivă, cu aceeași semnătură, în clasa derivată. Acest mecanism se numește ascundere (hiding):
 +
 +
<syntaxhighlight lang="C++" line highlight="39-41">
 +
#include <string>
 +
#include <cstdio>
 +
 +
class Animal {
 +
    std::string mName;
 +
    std::string mColor;
 +
    int mAge;
 
protected:
 
protected:
−
     bool mHasFeathers; // accesibil din eventualele clase derivate
+
     bool mHasFeathers;
  
 
public:
 
public:
−
     virtual void makeSound() {
+
     Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
−
        std::cout << "Animal " << mName << " makes a sound!" << std::endl;
 
 
     }
 
     }
  
−
     void setName(std::string str) {
+
     void makeSound() const {
−
         mName = str;
+
         printf("Animal %s makes a sound!\n", mName.c_str());
 
     }
 
     }
  
 
     // this is a getter method
 
     // this is a getter method
−
     std::string getName() {
+
     std::string getName() const {
 
         return mName;
 
         return mName;
 
     }
 
     }
Linia 99: Linia 182:
 
};
 
};
  
−
class Pisica : public Animal {
+
class Cat : public Animal {
 +
    unsigned int mLives;
 +
public:
 +
    Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
 +
        mHasFeathers = false;
 +
    }
 +
 
 +
    void makeSound() const {
 +
        printf("Cat %s meows!\n", getName().c_str());
 +
    }
 +
};
 +
 
 +
int main() {
 +
    Animal animal("Rex", "black");
 +
    animal.makeSound();
 +
    Cat cat("Spot", "tabby");
 +
    cat.makeSound();
 +
    return 0;
 +
}
 +
</syntaxhighlight>
 +
 
 +
Ieșire:
 +
<syntaxhighlight lang="text">
 +
Animal Rex makes a sound!
 +
Cat Spot meows!
 +
</syntaxhighlight>
 +
 
 +
= Polimorfismul =
 +
 
 +
== Introducere ==
 +
Polimorfismul -- din greacă "poly" (mai multe) and "morphe" (forme) -- se referă la faptul că un obiect care este de tipul unei clase derivate, este în același timp și de tipul clasei de bază. Altfel spus:
 +
 
 +
<div class="regula"><font color="#ff0000">Atenție: </font>Dacă o clasă <code>B</code> extinde (direct sau indirect) o clasă <code>A</code>, atunci un obiect <code>b</code> de tipul <code>B</code> este în același timp și de tipul <code>A</code>.</div>
 +
 
 +
Folosind acest concept, care este implementat și în limbajul C++, se pot utiliza pointeri sau referințe de un tip <code>T</code> pentru a referi obiecte de tipuri derivate din <code>T</code>.
 +
 
 +
== Exemplu ==
 +
 
 +
<syntaxhighlight lang="C++" line highlight="50">
 +
#include <string>
 +
#include <cstdio>
 +
 
 +
class Animal {
 +
    std::string mName;
 +
    std::string mColor;
 +
    int mAge;
 +
protected:
 +
    bool mHasFeathers;
 +
 
 
public:
 
public:
−
     Pisica() : Animal() { mHasFeathers = false; }
+
     Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
 +
    }
  
−
    // cuvantul '''override''' este optional dar recomandat si produce o eroare de compilare daca metoda makeSound din Pisica nu suprascrie metoda
+
     void makeSound() const {
−
    // makeSound din Animal din cauza unei erori de sintaxa (eg. nume usor schimbat, alt return type, alti parametri / ordine sau tip al lor
+
         printf("Animal %s makes a sound!\n", mName.c_str());
−
     void makeSound() override {
+
    }
−
         std::cout << "Pisica " << getName() << " makes a sound!" << std::endl;
+
 
 +
    // this is a getter method
 +
    std::string getName() const {
 +
        return mName;
 
     }
 
     }
  
−
     // metoda din clasa Pisica ascunde implementarea din clasa Animal, dar nu o suprascrie polimorfic pentru ca setAge nu este virtuala in Animal
+
     // this is a setter method
 
     void setAge(int age) {
 
     void setAge(int age) {
−
         if (age >= 20) std::cout << "WARN: Longeviva pisica... sigur nu este o greseala?" << std::endl;
+
         if(age > 0) {
 +
            mAge = age;
 +
        }
 +
    }
 +
};
  
−
        Animal::setAge(age); // chemare setAge din clasa de baza Animal
+
class Cat : public Animal {
 +
    unsigned int mLives;
 +
public:
 +
    Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
 +
        mHasFeathers = false;
 
     }
 
     }
−
};
+
 
 +
    void makeSound() const {
 +
        printf("Cat %s meows!\n", getName().c_str());
 +
    }
 +
};  
  
 
int main() {
 
int main() {
 +
    Animal animal("Rex", "black");
 +
    Cat cat("Spot", "tabby");
 +
 +
    Animal & animalRef = animal;
 +
    Cat & catRef = cat;
 +
    Animal & catRef2 = cat;
 +
 +
    animalRef.makeSound();
 +
    catRef.makeSound();
 +
    catRef2.makeSound();
 +
 +
    return 0;
 +
}
 +
</syntaxhighlight>
 +
 +
Ieșire:
 +
<syntaxhighlight lang="text">
 +
Animal Rex makes a sound!
 +
Cat Spot meows!
 +
Animal Spot makes a sound!
 +
</syntaxhighlight>
 +
 +
Se vede că pe linia 50 de mai sus, avem o referință de tip <code>Animal</code> la un obiect de tip <code>Cat</code>. Acest lucru este posibil pentru că o <code>Cat</code> este în același timp și un <code>Animal</code> (deoarece <code>Cat</code> extinde <code>Animal</code>). Totuși, se poate observa din textul de ieșire că deși referințele <code>catRef</code> și <code>catRef2</code> sunt către același obiect (de tip <code>Cat</code>), apelul metodei <code>makeSound</code> se face în funcție de tipul referinței, nu de tipul obiectului. Există însă scenarii în care se dorește comportamentul invers, anume apelul metodei în funcție de tipul obiectului, nu de tipul referinței cu care este accesat. Astfel, se introduce conceptul de '''metodă virtuală'''.
 +
 +
= Metode virtuale și suprascrierea metodelor =
 +
== Introducere ==
 +
 +
Dacă o metodă este declarată virtuală, folosind cuvântul cheie <code>virtual</code> plasat în fața tipului întors, atunci reimplementarea acesteia în clasele derivate se numește '''suprascriere'''. Apelul unei metode virtuale folosind o referință de alt tip decât al clasei din care face parte obiectul, va apela metoda corespunzătoare obiectului în sine, nu cea care aparține tipului referinței.
  
−
    std::cout << std::endl << "Demo Animal:" << std::endl;
+
== Exemplu ==
−
    Animal *pAnimal;
+
<syntaxhighlight lang="C++" line highlight="15,39">
−
    Animal un_animal;
+
#include <string>
−
    un_animal.setName("TestoasaNinja");
+
#include <cstdio>
  
−
     un_animal.makeSound(); // metoda makeSound din clasa Animal
+
class Animal {
−
     un_animal.setAge(99); // metoda setAge din clasa Animal
+
    std::string mName;
 +
    std::string mColor;
 +
    int mAge;
 +
protected:
 +
    bool mHasFeathers;
 +
 
 +
public:
 +
     Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
 +
    }
 +
 
 +
    virtual void makeSound() const {
 +
        printf("Animal %s makes a sound!\n", mName.c_str());
 +
    }
 +
 
 +
    // this is a getter method
 +
     std::string getName() const {
 +
        return mName;
 +
    }
 +
 
 +
    // this is a setter method
 +
    void setAge(int age) {
 +
        if(age > 0) {
 +
            mAge = age;
 +
        }
 +
    }
 +
};
  
−
     pAnimal = &un_animal;
+
class Cat : public Animal {
−
     pAnimal->makeSound(); // metoda makeSound din clasa Animal
+
     unsigned int mLives;
−
    pAnimal->setAge(99); // metoda setAge din clasa Animal
+
public:
 +
     Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
 +
        mHasFeathers = false;
 +
    }
  
−
     std::cout << std::endl << "Demo Pisica:" << std::endl;
+
     void makeSound() const override {
−
    Pisica tom;
+
        printf("Cat %s meows!\n", getName().c_str());
−
    tom.setName("Tom");
+
     }
−
    tom.makeSound(); // metoda makeSound din clasa Pisica
+
};  
−
     tom.setAge(20); // metoda setAge din clasa Pisica
 
  
−
    Pisica *pPisica;
+
int main() {
−
    pPisica = &tom;
+
     Animal animal("Rex", "black");
−
     pPisica->makeSound(); // metoda makeSound din clasa Pisica
+
     Cat cat("Spot", "tabby");
−
     pPisica->setAge(20); // metoda setAge din clasa Pisica
 
  
−
     // demonstratie POLIMORFISM (de mostenire):
+
     Animal & animalRef = animal;
−
    std::cout << std::endl << "Demo Polimorfism (de mostenire):" << std::endl;
+
     Cat & catRef = cat;
−
     pAnimal = &tom; // pointer de tip clasa de baza Animal, care contine o adresa de tip clasa derivata, Pisica
+
     Animal & catRef2 = cat;
−
     pAnimal->makeSound(); // ATENTIE: medoda makeSound din clasa Pisica (makeSound ESTE virtuala in clasa de baza Animal)
 
−
    pAnimal->setAge(20); // ATENTIE: metoda setAge din clasa Animal (setAge NU este virtuala in clasa de baza Animal)
 
  
−
     // pPisica = &un_animal; // eroare de compilare: invalid conversion from ‘Animal*’ to ‘Pisica*’ [-fpermissive]
+
     animalRef.makeSound();
 +
    catRef.makeSound();
 +
    catRef2.makeSound();
  
 
     return 0;
 
     return 0;
Linia 154: Linia 355:
 
</syntaxhighlight>
 
</syntaxhighlight>
  
−
Secventa de mai sus afiseaza:
+
Ieșire:
 +
<syntaxhighlight lang="text">
 +
Animal Rex makes a sound!
 +
Cat Spot meows!
 +
Cat Spot meows!
 +
</syntaxhighlight>
  
−
<syntaxhighlight>
+
<div class="sfat"><font color="darkgreen">Sfat:</font> Când se suprascrie o metodă într-o clasă derivată, este recomandat să plasați înainte de acolada deschisă care implementează metoda cuvântul cheie <code>override</code>. Deși acest lucru nu este obligatoriu, vă va avertiza printr-o eroare de compilare dacă suprascrierea nu se face corect (de exemplu dacă metoda din clasa de bază nu este declarată virtuală).</div>
−
Demo Animal:
 
−
Animal TestoasaNinja makes a sound!
 
−
Animal TestoasaNinja makes a sound!
 
  
−
Demo Pisica:
+
= Metode pur virtuale și clase abstracte =
−
Pisica Tom makes a sound!
 
−
WARN: Longeviva pisica... sigur nu este o greseala?
 
−
Pisica Tom makes a sound!
 
−
WARN: Longeviva pisica... sigur nu este o greseala?
 
  
−
Demo Polimorfism (de mostenire):
+
== Introducere ==
−
Pisica Tom makes a sound!
+
 
−
</syntaxhighlight>
+
În anumite situații, o metodă virtuală nu poate avea o implementare în clasa de bază, pentru că nu este cunoscut modul în care aceasta se comportă. În această situație, metoda poate fi definită ca fiind '''pur virtuală''', adică o metodă fără implementare, dar care este totuși declarată în cadrul clasei.
 +
 
 +
<div class="regula"><font color="#ff0000">Atenție: </font>Dacă o clasă conține cel puțin o metodă pur virtuală aceasta se numește '''clasă abstractă''' și nu poate fi instanțiată.</div>
 +
 
 +
Dacă am crea un obiect de tipul respectiv, atunci nu am putea apela metoda pur virtuală pentru că implementarea aceasteia lipsește. Clasele abstracte se pot folosi numai pentru a fi extinse, și metodele pur virtuale trebuie suprascrise în clasele derivate. Dacă cel puțin una din metodele pur virtuale nu este suprascrisă, atunci clasa derivată este la rândul ei abstractă.
 +
 
 +
== Exemplu ==
 +
 
 +
<syntaxhighlight lang="C++" line highlight="24,45">
 +
#include <string>
 +
#include <cstdio>
  
−
= Functii/Metode virtuale pure, clase abstracte =
+
class Animal {
 +
    std::string mName;
 +
    std::string mColor;
 +
    int mAge;
 +
protected:
 +
    bool mHasFeathers;
  
−
- o functie/metoda virtuala pura este o functie/metoda care nu are corp (body), nici macar gol
+
public:
 +
    Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
 +
    }
  
−
virtual std::string toString() {}; // nu este o functie/metoda virtuala pura, are corp
+
    virtual void makeSound() const {
 +
        printf("Animal %s makes a sound!\n", mName.c_str());
 +
    }
  
−
virtual std::string toString() = 0; // este o functie/metoda virtuala pura
+
    // this is a getter method
 +
    std::string getName() const {
 +
        return mName;
 +
    }
  
−
O clasa abstracta este o clasa care contine cel putin o metoda virtuala pura, si deci nu se poate instantia (nu exista obiecte de tip clasa
+
    virtual int getNumberOfLegs() const = 0;
  
−
Exemplu (pentru o clasa mostenita din clasa Animal de mai sus)
+
    // this is a setter method
 +
    void setAge(int age) {
 +
        if(age > 0) {
 +
            mAge = age;
 +
        }
 +
    }
 +
};
  
−
<syntaxhighlight lang="C++">
+
class Cat : public Animal {
−
class Pisica : public Animal {
+
    unsigned int mLives;
 
public:
 
public:
−
     Pisica() : Animal() // constructorul implicit Animal este chemat explicit
+
     Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
−
    {  
+
        mHasFeathers = false;
−
      mHasFeathers = false;
+
     }
−
     } // campul mHasFeathers este protected in Animal, deci poate fi accesat de Pisica
+
 
−
}; // nu uitati de ; la sfarsitul unei clase
+
    void makeSound() const override {
 +
        printf("Cat %s meows!\n", getName().c_str());
 +
    }
 +
 
 +
    int getNumberOfLegs() const override {
 +
        return 4;
 +
    }
 +
};
 +
 
 +
int main() {
 +
    Animal animal("Rex", "black"); // eroare de compilare, Animal este clasa abstracta
 +
   
 +
    Cat cat("Spot", "tabby");
 +
    Cat & catRef = cat;
 +
    Animal & catRef2 = cat;
 +
 
 +
    catRef.makeSound();
 +
    catRef2.makeSound();
 +
 
 +
    return 0;
 +
}
 
</syntaxhighlight>
 
</syntaxhighlight>

Versiunea curentă din 12 aprilie 2022 22:01

Această lucrare are ca scop familiarizarea cu următoarele noțiuni:

  • Moștenirea
  • Ascunderea metodelor
  • Polimorfismul
  • Metode virtuale și suprascrierea metodelor
  • Metode pur virtuale și clase abstracte

Moștenirea

Introducere

Moștenirea este mecanismul prin care o clasă preia structura (câmpurile) și comportamentul (metodele) unei alte (sau mai multor) clase, la care poate adăuga alți membri specifici.

Clasa de la care se preiau membrii se numește:

  • clasă de bază
  • superclasă

Clasa nouă, care preia membrii de la clasa de bază se numește:

  • clasă derivată
  • clasă extinsă
  • subclasă

În C++, moștenirea poate fi multiplă, în sensul că o clasă derivată poate moșteni mai multe clase de bază. Nu în toate limbajele există acest concept (în Java, de exemplu, există doar moștenire simplă - adică o clasă poate moșteni o singură altă clasă).

Utilitatea moștenirii în programarea orientată pe obiecte este:

  • reutilizarea codului existent fără modificarea acestuia;
  • extinderea a unei clase deja scrise, fără a fi necesară recompilarea ei;
  • utilizarea polimorfismului în timpul execuției, prin folosirea metodelor virtuale.

Exemplu

 1#include <string>
 2#include <cstdio>
 3
 4class Animal {
 5    std::string mName;
 6    std::string mColor;
 7    int mAge;
 8protected:
 9    bool mHasFeathers;
10
11public:
12    void makeSound() const {
13        printf("Animal %s makes a sound!\n", mName.c_str());
14    }
15
16    // this is a getter method
17    std::string getName() const {
18        return mName;
19    }
20
21    // this is a setter method
22    void setAge(int age) {
23        if(age > 0) {
24            mAge = age;
25        }
26    }
27};
28
29class Cat : public Animal {
30    unsigned int mLives;
31public:
32    Cat() : mLives(9) {
33        mHasFeathers = false;
34    }
35}; 
36
37int main() {
38    Cat cat;
39    cat.makeSound(); // makeSound este mostenita din clasa Animal
40    return 0;
41}

În exemplul de mai sus, clasa Cat preia toți membrii din clasa Animal și adaugă un câmp mLives și un constructor fără argumente. S-a introdus, de asemenea, un nou modificator de acces, protected, care permite accesul la membrul respectiv atât din clasa curentă cât și din orice clasă derivată din clasa curentă, dar nu și din alte clase sau funcții.

Se observă, de asemenea, că moștenirea a fost declarată publică. Există două timpuri de moșteniri:

  1. publică
  2. privată

Relativ la tipul de moștenire, mai jos este prezentat modul în care se preiau membrii din clasa de bază:

Accesul asupra membrilor moșteniți
Protecția in clasa de baza Modificatorul de acces utilizat în lista claselor de bază Dreptul de acces în clasa derivată
public public public
private public inaccesibil
protected public protected
public private private
private private inaccesibil
protected private private
Atenție: A doua diferență între class și struct este că pentru prima, moștenirea implicită este private iar pentru a doua este public.

Apelul constructorului superclasei

Când se instanțiază o clasă derivată, constructorul acestei clase se ocupă de inițializarea câmpurilor definite în clasa derivată. Pentru a inițializa câmpurile din clasa de bază, este necesar să apelăm constructorul ei. Prin urmare:

Atenție: Obligatoriu, constructorul unei clase derivate trebuie să apeleze constructorul clasei de bază. Dacă acest apel nu se face explicit, compilatorul va introduce un apel către constructorul clasei de bază fără argumente. Dacă acesta lipsește, apelul către constructorul clasei de bază trebuie făcut explicit, altfel se va genera o eroare de compilare.

Apelul constructorului superclasei se face folosind aceeași sintaxă ca pentru inițializarea câmpurilor: 

 1class Animal {
 2    std::string mName;
 3    std::string mColor;
 4    int mAge;
 5protected:
 6    bool mHasFeathers;
 7
 8public:
 9    Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
10    }
11
12    void makeSound() const {
13        printf("Animal %s makes a sound!\n", mName.c_str());
14    }
15
16    // this is a getter method
17    std::string getName() const {
18        return mName;
19    }
20
21    // this is a setter method
22    void setAge(int age) {
23        if(age > 0) {
24            mAge = age;
25        }
26    }
27};
28
29class Cat : public Animal {
30    unsigned int mLives;
31public:
32    Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
33        mHasFeathers = false;
34    }
35};

Ascunderea metodelor

În anumite situații, există nevoia ca o anumită metodă care este moștenită din clasa de bază să se comporte altfel în clasa derivată. Putem realiza acest lucru reimplementând metoda respectivă, cu aceeași semnătură, în clasa derivată. Acest mecanism se numește ascundere (hiding): 

 1#include <string>
 2#include <cstdio>
 3
 4class Animal {
 5    std::string mName;
 6    std::string mColor;
 7    int mAge;
 8protected:
 9    bool mHasFeathers;
10
11public:
12    Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
13    }
14
15    void makeSound() const {
16        printf("Animal %s makes a sound!\n", mName.c_str());
17    }
18
19    // this is a getter method
20    std::string getName() const {
21        return mName;
22    }
23
24    // this is a setter method
25    void setAge(int age) {
26        if(age > 0) {
27            mAge = age;
28        }
29    }
30};
31
32class Cat : public Animal {
33    unsigned int mLives;
34public:
35    Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
36        mHasFeathers = false;
37    }
38
39    void makeSound() const {
40        printf("Cat %s meows!\n", getName().c_str());
41    }
42}; 
43
44int main() {
45    Animal animal("Rex", "black");
46    animal.makeSound();
47    Cat cat("Spot", "tabby");
48    cat.makeSound();
49    return 0;
50}

Ieșire: 

Animal Rex makes a sound!
Cat Spot meows!

Polimorfismul

Introducere

Polimorfismul -- din greacă "poly" (mai multe) and "morphe" (forme) -- se referă la faptul că un obiect care este de tipul unei clase derivate, este în același timp și de tipul clasei de bază. Altfel spus:

Atenție: Dacă o clasă B extinde (direct sau indirect) o clasă A, atunci un obiect b de tipul B este în același timp și de tipul A.

Folosind acest concept, care este implementat și în limbajul C++, se pot utiliza pointeri sau referințe de un tip T pentru a referi obiecte de tipuri derivate din T.

Exemplu

 1#include <string>
 2#include <cstdio>
 3
 4class Animal {
 5    std::string mName;
 6    std::string mColor;
 7    int mAge;
 8protected:
 9    bool mHasFeathers;
10
11public:
12    Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
13    }
14
15    void makeSound() const {
16        printf("Animal %s makes a sound!\n", mName.c_str());
17    }
18
19    // this is a getter method
20    std::string getName() const {
21        return mName;
22    }
23
24    // this is a setter method
25    void setAge(int age) {
26        if(age > 0) {
27            mAge = age;
28        }
29    }
30};
31
32class Cat : public Animal {
33    unsigned int mLives;
34public:
35    Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
36        mHasFeathers = false;
37    }
38
39    void makeSound() const {
40        printf("Cat %s meows!\n", getName().c_str());
41    }
42}; 
43
44int main() {
45    Animal animal("Rex", "black");
46    Cat cat("Spot", "tabby");
47
48    Animal & animalRef = animal;
49    Cat & catRef = cat;
50    Animal & catRef2 = cat;
51
52    animalRef.makeSound();
53    catRef.makeSound();
54    catRef2.makeSound();
55
56    return 0;
57}

Ieșire: 

Animal Rex makes a sound!
Cat Spot meows!
Animal Spot makes a sound!

Se vede că pe linia 50 de mai sus, avem o referință de tip Animal la un obiect de tip Cat. Acest lucru este posibil pentru că o Cat este în același timp și un Animal (deoarece Cat extinde Animal). Totuși, se poate observa din textul de ieșire că deși referințele catRef și catRef2 sunt către același obiect (de tip Cat), apelul metodei makeSound se face în funcție de tipul referinței, nu de tipul obiectului. Există însă scenarii în care se dorește comportamentul invers, anume apelul metodei în funcție de tipul obiectului, nu de tipul referinței cu care este accesat. Astfel, se introduce conceptul de metodă virtuală.

Metode virtuale și suprascrierea metodelor

Introducere

Dacă o metodă este declarată virtuală, folosind cuvântul cheie virtual plasat în fața tipului întors, atunci reimplementarea acesteia în clasele derivate se numește suprascriere. Apelul unei metode virtuale folosind o referință de alt tip decât al clasei din care face parte obiectul, va apela metoda corespunzătoare obiectului în sine, nu cea care aparține tipului referinței.

Exemplu

 1#include <string>
 2#include <cstdio>
 3
 4class Animal {
 5    std::string mName;
 6    std::string mColor;
 7    int mAge;
 8protected:
 9    bool mHasFeathers;
10
11public:
12    Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
13    }
14
15    virtual void makeSound() const {
16        printf("Animal %s makes a sound!\n", mName.c_str());
17    }
18
19    // this is a getter method
20    std::string getName() const {
21        return mName;
22    }
23
24    // this is a setter method
25    void setAge(int age) {
26        if(age > 0) {
27            mAge = age;
28        }
29    }
30};
31
32class Cat : public Animal {
33    unsigned int mLives;
34public:
35    Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
36        mHasFeathers = false;
37    }
38
39    void makeSound() const override {
40        printf("Cat %s meows!\n", getName().c_str());
41    }
42}; 
43
44int main() {
45    Animal animal("Rex", "black");
46    Cat cat("Spot", "tabby");
47
48    Animal & animalRef = animal;
49    Cat & catRef = cat;
50    Animal & catRef2 = cat;
51
52    animalRef.makeSound();
53    catRef.makeSound();
54    catRef2.makeSound();
55
56    return 0;
57}

Ieșire: 

Animal Rex makes a sound!
Cat Spot meows!
Cat Spot meows!
Sfat: Când se suprascrie o metodă într-o clasă derivată, este recomandat să plasați înainte de acolada deschisă care implementează metoda cuvântul cheie override. Deși acest lucru nu este obligatoriu, vă va avertiza printr-o eroare de compilare dacă suprascrierea nu se face corect (de exemplu dacă metoda din clasa de bază nu este declarată virtuală).

Metode pur virtuale și clase abstracte

Introducere

În anumite situații, o metodă virtuală nu poate avea o implementare în clasa de bază, pentru că nu este cunoscut modul în care aceasta se comportă. În această situație, metoda poate fi definită ca fiind pur virtuală, adică o metodă fără implementare, dar care este totuși declarată în cadrul clasei.

Atenție: Dacă o clasă conține cel puțin o metodă pur virtuală aceasta se numește clasă abstractă și nu poate fi instanțiată.

Dacă am crea un obiect de tipul respectiv, atunci nu am putea apela metoda pur virtuală pentru că implementarea aceasteia lipsește. Clasele abstracte se pot folosi numai pentru a fi extinse, și metodele pur virtuale trebuie suprascrise în clasele derivate. Dacă cel puțin una din metodele pur virtuale nu este suprascrisă, atunci clasa derivată este la rândul ei abstractă.

Exemplu

 1#include <string>
 2#include <cstdio>
 3
 4class Animal {
 5    std::string mName;
 6    std::string mColor;
 7    int mAge;
 8protected:
 9    bool mHasFeathers;
10
11public:
12    Animal(const std::string & name, const std::string & color) : mName(name), mColor(color) {
13    }
14
15    virtual void makeSound() const {
16        printf("Animal %s makes a sound!\n", mName.c_str());
17    }
18
19    // this is a getter method
20    std::string getName() const {
21        return mName;
22    }
23
24    virtual int getNumberOfLegs() const = 0;
25
26    // this is a setter method
27    void setAge(int age) {
28        if(age > 0) {
29            mAge = age;
30        }
31    }
32};
33
34class Cat : public Animal {
35    unsigned int mLives;
36public:
37    Cat(const std::string & name, const std::string & color) : Animal(name, color), mLives(9) {
38        mHasFeathers = false;
39    }
40
41    void makeSound() const override {
42        printf("Cat %s meows!\n", getName().c_str());
43    }
44
45    int getNumberOfLegs() const override {
46        return 4;
47    }
48}; 
49
50int main() {
51    Animal animal("Rex", "black"); // eroare de compilare, Animal este clasa abstracta
52    
53    Cat cat("Spot", "tabby");
54    Cat & catRef = cat;
55    Animal & catRef2 = cat;
56
57    catRef.makeSound();
58    catRef2.makeSound();
59
60    return 0;
61}
Adus de la „http://wiki.dcae.pub.ro/index.php?title=C%2B%2B_POO_Lab_Lucrarea_4&oldid=7370”