C++ POO Lab Lucrarea 4

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

#include <string>
#include <cstdio>

class Animal {
    std::string mName;
    std::string mColor;
    int mAge;
protected:
    bool mHasFeathers;

public:
    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() : mLives(9) {
        mHasFeathers = false;
    }
}; 

int main() {
    Cat cat;
    cat.makeSound(); // makeSound este mostenita din clasa Animal
    return 0;
}

Î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:

class 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) {
    }

    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;
    }
};

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):

#include <string>
#include <cstdio>

class 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) {
    }

    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;
    }

    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;
}

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

#include <string>
#include <cstdio>

class 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) {
    }

    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;
    }

    void makeSound() const {
        printf("Cat %s meows!\n", getName().c_str());
    }
}; 

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;
}

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

#include <string>
#include <cstdio>

class 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;
        }
    }
};

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 override {
        printf("Cat %s meows!\n", getName().c_str());
    }
}; 

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;
}

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

#include <string>
#include <cstdio>

class 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;
    }

    virtual int getNumberOfLegs() const = 0;

    // 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;
    }

    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;
}