Polimorfizm

Polimorfizm to inaczej wielopostaciowość. Termin ten należy rozumieć jako mechanizmy zawarte w języku programowania, które pozwalają na traktowanie tych samych danych (np. zmiennych, obiektów) w różny sposób. Aby dokładnie zrozumieć ten paradygmat, musimy na początku zaznajomić się z metodami wirtualnymi. Dopiero później będziemy w stanie zrozumieć wielopostaciowość, która w języku C++ związana jest głównie z obiektami dynamicznymi.

Metody wirtualne

Metody wirtualne to ważna część polimorfizmu i abstrakcji. Są to metody, których definicja jest wielopostaciowa — mogą być dziedziczone, nadpisywane oraz rozszerzane w klasach pochodnych.

W języku C++ deklarację metody wirtualnej poprzedzamy słowem kluczowym virtual. Jeśli chcemy utworzyć metodę czysto wirtualnąmetoda czysto wirtualnametodę czysto wirtualną, po deklaracji funkcji dopisujemy =0. Przykład:

class Zwierze {
public:
	virtual void jedz() = 0;
};

Metoda zadeklarowana w linijce 3. jest metodą czysto wirtualną.

Klasa Zwierze jest klasą abstrakcyjną — każda klasa, która oparta jest na klasie Zwierze, musi nadpisać metodę jedz().

Zaimplementujmy dwie dodatkowe klasy, które dziedziczą po sobie oraz klasie Zwierze.

#include <iostream>
using namespace std;

class Zwierze {
public:
	virtual void jedz() = 0;
};

class Antylopa : public Zwierze {
public:
	void jedz() override {
		cout << "Antylopa zjada trawe" << endl;
	}

	void biegnij() {
		cout << "Antylopa biegnie" << endl;
	};
};

class Gnu : public Antylopa {
public:
	void jedz() override {
		cout << "Gnu ";
		Antylopa::jedz();
	}
};

Nadpisując metodę wirtualną, możemy zastosować słowo kluczowe override. Nie jest ono wymagane dla poprawności kodu, ale zwiększa jego czytelność. Nadpisanie metody nie może zmienić jej typu ani właściwości, a jedynie kod, który wykonuje.

Warto zauważyć, że jeśli oznaczymy metodę słowem kluczowym virtual w klasie bazowej, będzie ona wirtualna również we wszystkich klasach pochodnych. Przykładem jest klasa Gnu – zostaje w niej nadpisana wirtualna metoda z klasy nadrzędnej Antylopa, mimo że nie była oznaczona słowem virtual. Dzieje się tak, ponieważ klasa Antylopa dziedziczy po klasie Zwierzę, gdzie metoda jedz() jest oznaczona jako wirtualna.

Zwróć uwagę na odwołanie do metody jedz() z klasy bazowej w linijce 24. Możemy w trakcie realizacji metody pochodnej wykonać kod, który zdefiniowany jest w klasie bazowej. Dzięki temu nadpisywanie metody nie ogranicza się do zdefiniowania funkcji na nowo, ale umożliwia także jej rozszerzanie.

W linijce 15. została zadeklarowana metoda biegnij(). Nie jest ona metodą wirtualną, więc nie można jej nadpisać w klasie Gnu. Jeżeli spróbujemy to zrobić, kompilator potraktuje to jako błąd.

Spróbujmy zatem nadpisać metodę biegnij() z klasy Antylopa w klasie Gnu. Jednak na razie nie zmieniajmy kodu klasy Antylopa.

#include <iostream>
using namespace std;

class Zwierze {
public:
	virtual void jedz() = 0;
};

class Antylopa : public Zwierze {
public:
	void jedz() override {
		cout << "Antylopa zjada trawe" << endl;
	}

	void biegnij() {
		cout << "Antylopa biegnie" << endl;
	};
};

class Gnu : public Antylopa {
public:
	void jedz() override {
		cout << "Gnu ";
		Antylopa::jedz();
	}
    
	// błędne nadpisanie metody niewirtualnej
	void biegnij() override {
		cout << "Gnu ";
		Antylopa::biegnij();
	}
};

Podczas próby kompilacji przedstawionego kodu powinien wystąpić błąd. Aby nadpisać metodę biegnij() z klasy Antylopa, poprzedzamy jej definicję słowem kluczowym virtual. Przedstawiony poniżej kod powinien skompilować się poprawnie.

#include <iostream>
using namespace std;

class Zwierze {
public:
	virtual void jedz() = 0;
};

class Antylopa : public Zwierze {
public:
	void jedz() override {
		cout << "Antylopa zjada trawe" << endl;
	}

	virtual void biegnij() {
		cout << "Antylopa biegnie" << endl;
	};
};

class Gnu : public Antylopa {
public:
	void jedz() override {
		cout << "Gnu ";
		Antylopa::jedz();
	}
    
	void biegnij() override {
		cout << "Gnu biegnie";
	}
};

W celu przetestowania stworzonych klas, możemy napisać funkcję główną programu, w której utworzymy obiekty klasy Antylopa oraz Gnu. Następnie wywołamy na nich metody jedz() oraz biegnij().

#include <iostream>
using namespace std;

class Zwierze {
public:
	virtual void jedz() = 0;
};

class Antylopa : public Zwierze {
public:
	void jedz() override {
		cout << "Antylopa zjada trawe" << endl;
	}

	virtual void biegnij() {
		cout << "Antylopa biegnie" << endl;
	};
};

class Gnu : public Antylopa {
public:
	void jedz() override {
		cout << "Gnu ";
		Antylopa::jedz();
	}
    
	void biegnij() override {
		cout << "Gnu biegnie";
	}
};

int main() {
	Antylopa antylopa;
	Gnu gnu;
    
	antylopa.jedz();
	antylopa.biegnij();
	gnu.jedz();
	gnu.biegnij();
	
    return 0;
}

Przedstawiony program powinien wypisać w konsoli:

Antylopa zjada trawe
Antylopa biegnie
Gnu Antylopa zjada trawe
Gnu biegnie

Polimorfizm dynamiczny

W języku C++ możemy definiować tablice obiektów dynamicznych tego samego typu bazowego, jednak różniących się typem pochodnym. Warto w tym miejscu omówić dwa przykłady.

Kod pierwszego przykładu wygląda następująco:

#include <iostream>
using namespace std;

class Zwierze {
public:
	virtual void jedz() = 0;
};

class Kot : public Zwierze {
public:
	void jedz() override {
		cout << "Kot zjada mysz" << endl;
	}

	void biegnij() {
		cout << "Kot biegnie" << endl;
	};
};

class Antylopa : public Zwierze {
public:
	void jedz() override {
		cout << "Antylopa zjada trawe" << endl;
	}

	void biegnij() {
		cout << "Antylopa biegnie" << endl;
	};
};

class Gnu : public Antylopa {
public:
	void jedz() override {
		cout << "Gnu ";
		Antylopa::jedz();
	}
};

int main() {
	/* przykład pierwszy */
	Zwierze* tablica_zwierzat[3] = {
		new Antylopa(),
		new Gnu(),
		new Kot()
	};

	for (int i = 0; i < 3; ++i) {
		(*tablica_zwierzat[i]).jedz();
		// element tablicy jest traktowany jako Zwierze
		// (nie jako Antylopa)
		// - brak metody biegnij w klasie Zwierze
		// (*tablica_zwierzat[i]).biegnij();
	}

	// każdy obiekt dynamiczny musi zostać usunięty
	for (int i = 0; i < 3; ++i) {
		delete tablica_zwierzat[i];
	}
	
    return 0;
}

W przedstawionym przykładzie została dodana prosta klasa Kot dziedzicząca po klasie Zwierze.

W funkcji głównej programu deklarujemy trójelementową tablicę wskaźników na obiekty dynamiczne typu Zwierze. Dzięki wbudowanemu w język C++ polimorfizmowi możemy taką tablicę wypełnić wskaźnikami na różne obiekty dynamiczne, których klasy dziedziczą po typie Zwierze. Jak widać na przykładzie, w deklaracji tablicy tworzymy nowe obiekty typu Antylopa, Gnu oraz Kot.

W linijce 48. dla każdego obiektu, na który wskazują wskaźniki z tablicy tablica_zwierząt, wywołujemy metodę jedz(). Zastanów się, jaki będzie wynik programu. Przetestuj jego działanie.

Antylopa zjada trawe
Gnu Antylopa zjada trawe
Kot zjada mysz

Zwróć uwagę na to, że wszystkie obiekty, na które wskazują elementy tablicy tablica_zwierząt, traktowane są jako obiekty klasy Zwierze. Oznacza to, że metody, które chcemy wywołać, muszą być widoczne w klasie bazowej Zwierze. Sprawdź, co się stanie, gdy odkomentujemy linijkę nr 52 i spróbujemy wywołać metodę, która nie występuje w klasie Zwierze. Mimo że każdy obiekt posiada metodę biegnij(), wystąpi błąd, gdyż nie jest ona widoczna z poziomu klasy Zwierze.

Przykład drugi:

#include <iostream>
using namespace std;

class Zwierze {
public:
	virtual void jedz() = 0;
};

class Kot : public Zwierze {
public:
	void jedz() override {
		cout << "Kot zjada mysz" << endl;
	}

	void biegnij() {
		cout << "Kot biegnie" << endl;
	};
};

class Antylopa : public Zwierze {
public:
	void jedz() override {
		cout << "Antylopa zjada trawe" << endl;
	}

	void biegnij() {
		cout << "Antylopa biegnie" << endl;
	};
};

class Gnu : public Antylopa {
public:
	void jedz() override {
		cout << "Gnu ";
		Antylopa::jedz();
	}
};

int main() {
	/* przykład drugi */
	Antylopa* tablica_antylop[3] = {
		new Antylopa(),
		new Gnu(),
		new Antylopa()
	};

	for (int i = 0; i < 3; ++i) {
		(*tablica_antylop[i]).jedz();
		(*tablica_antylop[i]).biegnij();
	}

	// każdy obiekt dynamiczny musi zostać usunięty
	for (int i = 0; i < 3; ++i) {
		delete tablica_antylop[i];
	}
	
    return 0;
}

W tym przykładzie zmieniamy typ tablicy na Antylopa i tworzymy w niej dwa obiekty klasy Antylopa oraz jeden obiekt klasy Gnu. Zwróć uwagę, że każdy obiekt typu Gnu jest również obiektem typu Antylopa.

Uruchom przedstawiony kod i sprawdź, jakie otrzymasz wyniki. Zauważ, że w pętli w linijce $47.$ można wywołać obie metody jedz() oraz biegnij(), ponieważ wszystkie użyte metody są widoczne w klasie Antylopa. Ostatecznie wynik prezentuje się następująco:

Antylopa zjada trawe
Antylopa biegnie
Gnu Antylopa zjada trawe
Antylopa biegnie
Antylopa zjada trawe
Antylopa biegnie

Hermetyzacja w języku C++

Hermetyzacja to inaczej ukrywanie implementacji. Paradygmat ten odnosi się do danych oraz funkcji, które je modyfikują. Dzięki hermetyzacji możemy ukrywać dostęp do danych oraz metod, kontrolując tym samym interakcję między obiektami.

Z mechanizmem hermetyzacji powiązane są trzy podstawowe modyfikatory dostępumodyfikatory dostępumodyfikatory dostępu:

• prywatny (private) – zmienna może być modyfikowana i odczytywana tylko w klasie, w której została zadeklarowana,

• chroniony (protected) – zmienna może być modyfikowana i odczytywana w klasie, w której została zadeklarowana oraz w klasach pochodnych od klasy, w której została zadeklarowana,

• publiczny (public) – zmienna może być modyfikowana i odczytywana w dowolnym miejscu programu, w którym mamy dostęp do obiektu.

Dzięki nim mamy możliwość wydzielenia w strukturze klasy sekcji o różnym dostępie do pól oraz metod.

Aby zweryfikować działania modyfikatorów dostępu, umieśćmy w klasie bazowej Zwierze trzy zmienne: publiczną, chronioną i prywatną:

class Zwierze {
private:
	int zmiennaA = 1;
protected:
	int zmiennaB = 2;
public:
	int zmiennaC = 3;
	virtual void jedz() = 0;
};

Mamy poprawną deklarację trzech pól w klasie Zwierze. Napiszmy dwie metody, po jednej w klasie Zwierze i Antylopa, w których zbadamy dostęp do tych trzech zmiennych. Spróbujemy uzyskać dostęp do zmiennych oraz wypisać je na ekran. Jednocześnie w funkcji main umieścimy kod, w którym również spróbujemy sprawdzić dostęp do zawartości zmiennych. Kod prezentuje się następująco:

#include <iostream>
using namespace std;

class Zwierze {
private:
	int zmiennaA = 1;
protected:
	int zmiennaB = 2;
public:
	int zmiennaC = 3;
	virtual void jedz() = 0;

	void metoda1() {
		cout << zmiennaA << endl;
		cout << zmiennaB << endl;
		cout << zmiennaC << endl;
	}
};

class Antylopa : public Zwierze {
public:
	void jedz() override {
		cout << "Antylopa zjada trawe" << endl;
	}

	void biegnij() {
		cout << "Antylopa biegnie" << endl;
	};

	void metoda2() {
		cout << zmiennaA << endl;
		cout << zmiennaB << endl;
		cout << zmiennaC << endl;
	}
};

int main() {
	// instancja klasy Antylopa
	Antylopa antylopa;

	// dostęp z metody z klasy bazowej
	antylopa.metoda1();

	// dostęp z metody z klasy pochodnej
	antylopa.metoda2();

	// dostęp funkcji głównej programu
	cout << antylopa.zmiennaA << endl;
	cout << antylopa.zmiennaB << endl;
	cout << antylopa.zmiennaC << endl;

	return 0;
}

Możemy przypuszczać, że program nie uruchomi się, ponieważ w wielu przypadkach nie mamy dostępu do zmiennych, których wartość próbujemy poznać. Kluczowe są dla nas linijki nr 14, 15, 16 oraz nr 31, 32, 33, a także nr 48, 49, 50. Zastanów się, które z nich zostaną uznane przez kompilator z błędne. Oczywiście będą to linijki nr 31, 48 i 49.

Oto kod, w którym komentarzami oznaczono błędne wiersze. Dodano również wyjaśnienie, na czym polegał błąd:

#include <iostream>
using namespace std;

class Zwierze {
private:
	int zmiennaA = 1;
protected:
	int zmiennaB = 2;
public:
	int zmiennaC = 3;
	virtual void jedz() = 0;

	void metoda1() {
		cout << zmiennaA << endl;
		cout << zmiennaB << endl;
		cout << zmiennaC << endl;
	}
};

class Antylopa : public Zwierze {
public:
	void jedz() override {
		cout << "Antylopa zjada trawe" << endl;
	}

	void biegnij() {
		cout << "Antylopa biegnie" << endl;
	};

	void metoda2() {
		// dostęp do prywatnej zmiennej klasy bazowej
		// nie jest możliwy z klasy pochodnej
		// cout << zmiennaA << endl;
		cout << zmiennaB << endl;
		cout << zmiennaC << endl;
	}
};

int main() {
	// instancja klasy Antylopa
	Antylopa antylopa;

	// dostęp z metody z klasy bazowej
	antylopa.metoda1();

	// dostęp z metody z klasy pochodnej
	antylopa.metoda2();

	// dostęp funkcji głównej programu
	cout << antylopa.zmiennaC << endl;
	// dostęp do zmiennych prywatnych oraz chronionych
	// nie jest możliwy z poziomu funkcji głównej programu
	// cout << antylopa.zmiennaA << endl;
	// cout << antylopa.zmiennaB << endl;

	return 0;
}

Słownik