Poziomy dostępu w dziedziczeniu

Część sekcji Programowanie obiektowe ścieżki C++ w Coddy. Lekcja 49 z 104.

Wybrany typ dziedziczenia wpływa na dostęp do składowych klasy bazowej w klasie pochodnej. C++ oferuje trzy opcje: dziedziczenie public, protected i private.

Oto, jak każdy typ przekształca dostęp do składowych:

Składowa bazowa	dziedziczenie publiczne	dziedziczenie chronione	dziedziczenie prywatne
public	public	protected	private
protected	protected	protected	private
private	niedostępne	niedostępne	niedostępne

class Base {
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

class PublicDerived : public Base {
    // pub jest publiczny, prot jest chroniony, priv jest niedostępny
};

class ProtectedDerived : protected Base {
    // pub jest chroniony, prot jest chroniony, priv jest niedostępny
};

class PrivateDerived : private Base {
    // pub jest prywatny, prot jest prywatny, priv jest niedostępny
};

Dziedziczenie publiczne modeluje relacje „jest-a” i jest zdecydowanie najczęściej stosowanym rodzajem dziedziczenia. Dog to Animal, więc kod zewnętrzny może traktować go jako takie zwierzę.

Dziedziczenie chronione i prywatne modeluje relacje typu „zaimplementowany za pomocą”. Ukrywa interfejs klasy bazowej przed kodem zewnętrznym, co jest przydatne, gdy chcesz ponownie wykorzystać implementację bez ujawniania relacji dziedziczenia. W przypadku dziedziczenia prywatnego nawet klasy pochodne tracą dostęp do oryginalnych składowych klasy bazowej.

Wyzwanie

Łatwy

Przyjrzyjmy się, jak różne typy dziedziczenia wpływają na dostępność składowych, budując prostą hierarchię urządzeń. Utworzysz bazową klasę Device i trzy klasy pochodne, z których każda będzie używać innego typu dziedziczenia, aby na własne oczy zobaczyć, jak dziedziczenie publiczne, chronione i prywatne zmienia dostęp do składowych.

Rozmieścisz swój kod w dwóch plikach:

Device.h: Zdefiniuj bazową klasę Device z trzema składowymi o różnych poziomach dostępu:
- Publiczna składowa std::string model
- Chroniona składowa int serialNumber
- Prywatna składowa int internalCode (domyślnie ustawiona na 999)
- Publiczna metoda showModel(), która wypisuje: Model: <model>
Następnie utwórz trzy klasy pochodne, z których każda dziedziczy po Device z użyciem innego typu dziedziczenia:
- PublicDevice z użyciem dziedziczenia publicznego: dodaj metodę displaySerial(), która wypisuje: Serial: <serialNumber>
- ProtectedDevice z użyciem dziedziczenia chronionego: dodaj metodę displaySerial(), która wypisuje: Serial: <serialNumber>
- PrivateDevice z użyciem dziedziczenia prywatnego: dodaj metodę displaySerial(), która wypisuje: Serial: <serialNumber>
Każda klasa pochodna powinna mieć konstruktor przyjmujący nazwę modelu i numer seryjny, przekazujący model do klasy bazowej i ustawiający numer seryjny.
main.cpp: Wczytaj dwa wejścia (każde w osobnym wierszu):
1. Nazwę modelu (ciąg znaków)
2. Numer seryjny (liczba całkowita)
Utwórz po jednym obiekcie każdego typu pochodnego, używając tych samych wartości wejściowych. Następnie pokaż różnice w dostępie:

Dla PublicDevice:
- Wywołaj bezpośrednio na obiekcie showModel() (działa, ponieważ dziedziczenie publiczne zachowuje publiczny dostęp do tej metody)
- Uzyskaj bezpośredni dostęp do model i wypisz: Direct model access: <model>
- Wywołaj displaySerial()
Dla ProtectedDevice i PrivateDevice:
- Wywołaj tylko displaySerial() (odziedziczone showModel() i model nie są już publicznie dostępne z zewnątrz)
Format wyjściowy:
```
--- PublicDevice ---
Model: <model>
Direct model access: <model>
Serial: <serial>
--- ProtectedDevice ---
Serial: <serial>
--- PrivateDevice ---
Serial: <serial>
```

Na przykład dla wejść Laptop i 12345:

--- PublicDevice ---
Model: Laptop
Direct model access: Laptop
Serial: 12345
--- ProtectedDevice ---
Serial: 12345
--- PrivateDevice ---
Serial: 12345

Zwróć uwagę, że tylko PublicDevice umożliwia zewnętrzny dostęp do odziedziczonych składowych publicznych. Pozostałe typy dziedziczenia ukrywają interfejs klasy bazowej przed kodem zewnętrznym, ale klasy pochodne nadal mogą uzyskiwać wewnętrzny dostęp do składowych chronionych za pośrednictwem własnych metod.

Spróbuj swoich sił

#include <iostream>
#include <string>
#include "Device.h"

using namespace std;

int main() {
    // Odczytaj dane wejściowe
    string modelName;
    int serialNum;
    
    getline(cin, modelName);
    cin >> serialNum;
    
    // TODO: Utwórz obiekty każdego typu pochodnego, używając wartości wejściowych
    // PublicDevice pubDev(modelName, serialNum);
    // ProtectedDevice protDev(modelName, serialNum);
    // PrivateDevice privDev(modelName, serialNum);
    
    // TODO: Zademonstruj dostęp do PublicDevice
    cout << "--- PublicDevice ---" << endl;
    // - Wywołaj showModel() bezpośrednio na obiekcie
    // - Uzyskaj bezpośredni dostęp do model i wypisz: Direct model access: <model>
    // - Wywołaj displaySerial()
    
    // TODO: Zademonstruj dostęp do ProtectedDevice
    cout << "--- ProtectedDevice ---" << endl;
    // - Wywołaj tylko displaySerial() (showModel i model nie są publicznie dostępne)
    
    // TODO: Zademonstruj dostęp do PrivateDevice
    cout << "--- PrivateDevice ---" << endl;
    // - Wywołaj tylko displaySerial() (showModel i model nie są publicznie dostępne)
    
    return 0;
}