W poprzednich artykułach z kategorii „C++” omawiałem programy, które składały się z funkcji main, a w niektórych przypadkach również z innych funkcji zdefiniowanych przez programistę (np. do obliczania sumy). Takie rozwiązanie miało swoje wady i zalety, ale jak pewnie ambitne osoby zdążyły się zorientować, tego typu schemat pracy nie nadaje się do tworzenia dużych systemów informatycznych składających się z tysięcy linii kodu.
Pisząc programy komputerowe bez używania klas w końcu dochodzimy „do sufitu” orientując się, że dopisywanie kolejnych linijek w mainie, który zaczął rozrastać się do niebotycznych rozmiarów po prostu mija się z celem. Aby tworzenie aplikacji było łatwiejsze i bardziej intuicyjne wprowadzono coś takiego jak programowanie zorientowane obiektowo.
Pierwsza klasa
Siedząc przy biurku otacza nas bardzo wiele różnych przedmiotów takich jak, klawiatura, myszka, komputer, monitor czy po prostu długopis. W programowaniu każdą taką rzecz opisujemy klasą, a jej konkretny egzemplarz w programie to obiekt. Pisząc zwykłe programy w C++, też używamy obiektów na przykład klasy int, każda zmienna typu całkowitego to przecież taki obiekt:
int obiektKlasyInt; //tworzymy obiekt klasy int
obiektKlasyInt = 10;Czym więc są klasy? To nic innego jak wzorce obiektów, czyli opis jakiegoś rzeczywistego bądź abstrakcyjnego bytu (długopis, krzesło, stół, książka itd.), na podstawie którego tworzymy obiekty.
To na razie tyle z teorii, teraz przejdźmy do praktyki. Składnia klasy w C++ prezentuje się tak:
class NazwaKlasy {
};Gdzie NazwaKlasy to po prostu nazwa naszego obiektu jak okno, biurko itd. Bardziej ogólny kod z funkcją main:
#include <iostream>
using namespace std;
class NaszaPierwszaKlasa {
};
int main() {
return 0;
}Długopis jest pewnym obiektem, który służy do pisania na kartce papieru bądź w zeszycie dla naszych potrzeb kartką będzie ekran komputera. Skoro więc jest to obiekt i to jeszcze taki, który występuje w fizycznej formie to możemy stworzyć sobie klasę długopis:
#include <iostream>
using namespace std;
class Dlugopis {
};
int main() {
return 0;
}Mając klasę Dlugopis (na razie jeszcze nic ona nie robi) stwórzmy w funkcji main obiekt tej klasy:
Dlugopis dlugopis1; //tworzenie obiektu klasy DlugopisCały kod:
#include <iostream>
using namespace std;
class Dlugopis {
};
int main() {
Dlugopis dlugopis1;
return 0;
}A propos nazw klas to w programowaniu przyjęło się, że pisze się je z dużej litery.
Modyfikator dostępu
Klasa Dlugopis obecnie nic nie robi, pora więc dodać do niej jakieś elementy. Długopis używamy do pisania, więc przydałaby nam się metoda pisz(), która będzie odpowiedzialna za wyświetlanie podanego jako argument tekstu na ekranie.
class Dlugopis {
void pisz(string tekst) {
cout << tekst;
}
};Kod który stworzyliśmy wyżej zawiera pewien mały błąd. Mianowicie kiedy będziemy chcieli odwołać się do metody pisz() klasy Dlugopis kompilator zaprotestuje wyświetlając komunikat o błędzie. Stanie się tak dlatego, że nie użyliśmy tak zwanego modyfikatora dostępu czyli nie określiliśmy czy metoda ta jest publiczna, prywatna czy może chroniona:
| Modyfikator dostępu | Opis |
public | (Publiczny) – Dostęp do metod, pól itd. wewnątrz danej klasy oraz z poza niej. |
private | (Prywatny) – Dostęp do metod, pól itd. tylko z poziomu klasy w której dany element został zdefiniowany (wyjątek stanowi klasa zaprzyjaźniona – ang. friend). |
protected | (Chroniony) – Działa tak samo jak private z tym wyjątkiem, że metody, pola itd. są dostępne z poziomu klasy pochodnej (przy dziedziczeniu). |
Na razie rozpoczynamy zabawę z programowaniem obiektowym, więc będziemy używać tylko modyfikatora public. Aby skorzystać z modyfikatorów obiektowych należy w klasie napisać public:. Ważne jest to, iż taki zapis odnosi się do wszystkich elementów poniżej:
class NazwaKlasy {
public:
//pola, metody itd. publiczne
private:
//pola, metody itd. prywatne
protected:
//pola, metody itd. chronione
};Wracając do naszego przykładu to kod będzie wyglądał tak:
#include <iostream>
using namespace std;
class Dlugopis {
public:
void pisz(string tekst) {
cout << tekst;
}
};
int main() {
Dlugopis dlugopis1;
return 0;
}Przyszła teraz pora, żeby uruchomić naszą metodę pisz() klasy Dlugopis. Aby się do niej dostać najpierw musimy stworzyć odpowiedni obiekt, co już zresztą zrobiliśmy. Do metod odwołujemy się po znaku . (kropka). Ogólny kod:
nazwaObiektu.nazwaMetody();
nazwaObiektu.nazwaMetody(argumenty);W naszym przykładzie będzie wyglądało to tak:
dlugopis1.pisz("Napisałeś ten tekst...");Cały kod:
#include <iostream>
using namespace std;
class Dlugopis {
public:
void pisz(string tekst) {
cout << tekst;
}
};
int main() {
Dlugopis dlugopis1;
dlugopis1.pisz("Napisałeś ten tekst...");
return 0;
}Teraz możemy uruchomić powyższy kod, a w konsoli zobaczymy taki napis:
Napisałeś ten tekst...Gratulacje! Właśnie napisałeś swój pierwszy obiektowy program.
Pole
Nikt jednak nie zawracał by sobie głowy takim sposobem pisania oprogramowania gdyby możliwości klas były tak prymitywne jak powyższy przykład. Zapomnieliśmy przecież o tym, że nasz długopis może mieć wysunięty bądź wsunięty wkład. Oczywiste jest to, że jeżeli wkład jest wsunięty to nie możemy nic napisać. Rozbudujmy więc nasz program o kolejną funkcję.
Aby wiedzieć czy wkład jest wysunięty czy nie musimy tą informację gdzieś zapisać. Do tego celu wykorzystamy pole czyli innymi słowy zmienną:
bool czyWysuniety = false;Klasa Dlugopis:
class Dlugopis {
public:
bool czyWysuniety = false; //zakładamy, że wkład jest wsunięty (pesymistyczny przypadek)
void pisz(string tekst) {
cout << tekst;
}
};Jak widać, nowe pole dodałem po słowie kluczowym public ponieważ ono też musi być publiczne gdyż jego wartość będziemy modyfikować z poziomu funkcji main (czyli poza klasą). Od razu również przypisałem wartość false zakładając pesymistyczny przypadek. Należy jednak pamiętać iż wartości w klasie inicjalizujemy za pomocą konstruktora o czym będzie w dalszej części tego artykułu.
Następnym krokiem będzie zmodyfikowanie metody pisz(), tak aby zablokować możliwość „pisania” w momencie w którym wkład długopisu jest wsunięty. Do tego celu użyjemy zwykłą instrukcję warunkową IF:
void pisz(string tekst) {
if(czyWysuniety)
cout << tekst;
}Cała klasa:
class Dlugopis {
public:
bool czyWysuniety = false;
void pisz(string tekst) {
if(czyWysuniety)
cout << tekst;
}
};No i pozostało przejść do maina gdzie ustawiamy po prostu wartości pola czyWysuniety. Robi to się analogicznie jak odwoływanie do metod:
Ogólny kod:
nazwaObiektu.nazwaPola = wartosc;W naszym programie:
dlugopis1.czyWysuniety = true; //wysuwamy wkładCały kod:
#include <iostream>
using namespace std;
class Dlugopis {
public:
bool czyWysuniety = false;
void pisz(string tekst) {
if(czyWysuniety)
cout << tekst;
}
};
int main() {
Dlugopis dlugopis1;
dlugopis1.pisz("Napisałeś ten tekst..."); //to nie zostanie napisane
dlugopis1.czyWysuniety = true;
dlugopis1.pisz("Wkład wysunięty?"); //to już zostanie napisane, bo wkład jest wysunięty
return 0;
}Jak widać nasz program powoli zaczyna mieć ręce i nogi. Doskonale widać na tym przykładzie jak prosto w mainie dzięki klasom można modyfikować różne „stany” na przykład określając w którym momencie funkcja pisz() ma „pisać”.
Konstruktor
No to teraz do pełni szczęścia możemy dodać wspomniany już wcześniej konstruktor klasy. Najpierw jednak trochę teorii…
Konstruktor danej klasy to nic innego jak zwykła metoda nazwana dokładnie tak samo jak klasa. Idea konstruktora polega na tym, że operacje, które zawiera wykonywane są w momencie stworzenia obiektu danej klasy. Innymi słowy jeżeli mamy na przykład klasę JakasKlasa:
class JakasKlasa {
JakasKlasa() {
//operacje tutaj zawarte zostaną uruchomione w momencie stworzenia obiektu tej klasy
cout << "Stworzyłeś obiekt klasy JakasKlasa";
}
};To w momencie stworzenia jej obiektu w funkcji main:
JakasKlasa obiekt;Zostanie wywołana operacja z konstruktora czyli zostanie wyświetlony napis „Stworzyłeś obiekt klasy JakasKlasa„.
Przykładowy kod do uruchomienia:
#include <iostream>
using namespace std;
class JakasKlasa {
public:
JakasKlasa() {
//operacje tutaj zawarte zostaną uruchomione w momencie stworzenia obiektu tej klasy
cout << "Stworzyłeś obiekt klasy JakasKlasa";
}
};
int main() {
JakasKlasa obiekt; //zostanie wypisany napis "Stworzyłeś obiekt klasy JakasKlasa"
return 0;
}Pewnie zwróciłeś teraz uwagę na to, że konstruktor nie przyjmuje żadnych argumentów. Otóż konstruktor, który nie przyjmuje żadnych argumentów (tak jak powyżej w przykładzie) jest tak zwanym konstruktorem domyślnym. Konstruktor można oczywiście przeciążyć robi się to bardzo podobnie jak przeładowywanie nazw funkcji. Należy podać oczywiście inną liczbę argumentów, bądź argumenty innego typu. Tak więc konstruktorem przyjmującym jakieś argumenty nazywamy konstruktorem przeciążonym. Przykład:
#include <iostream>
using namespace std;
class JakasKlasa {
public:
JakasKlasa() {
//operacje tutaj zawarte zostaną uruchomione w momencie stworzenia obiektu tej klasy
cout << "Konstruktor domyślny";
}
//konstruktor przeciążony
JakasKlasa(string tekst) {
cout << tekst << endl;
}
};
int main() {
JakasKlasa obiekt("Konstruktor przeciążony"); //zostanie wypisany napis "Konstruktor przeciążony"
JakasKlasa obiekt1; //zostanie wypisany napis "Konstruktor domyślny"
return 0;
}Efekt naszego kodu:
Konstruktor przeciążony
Konstruktor domyślnyJak widać na powyższych przykładach konstruktor wywoływany jest w momencie stworzenia obiektu. W praktyce jest on więc wykorzystywany do inicjalizacji pól itd. czyli w skrócie do przygotowania obiektu do pracy (np. nadania polom wartości początkowych).
Wróćmy teraz do naszego przykładu:
#include <iostream>
using namespace std;
class Dlugopis {
public:
bool czyWysuniety = false;
void pisz(string tekst) {
if(czyWysuniety)
cout << tekst;
}
};
int main() {
Dlugopis dlugopis1;
dlugopis1.pisz("Napisałeś ten tekst..."); //to nie zostanie napisane
dlugopis1.czyWysuniety = true;
dlugopis1.pisz("Wkład wysunięty?"); //to już zostanie napisane, bo wkład jest wysunięty
return 0;
}I dopiszmy zwykły konstruktor domyślny, który zainicjalizuje pole czyWysuniety:
#include <iostream>
using namespace std;
class Dlugopis {
public:
Dlugopis() {
czyWysuniety = false;
}
bool czyWysuniety;
void pisz(string tekst) {
if(czyWysuniety)
cout << tekst;
}
};
int main() {
Dlugopis dlugopis1;
dlugopis1.pisz("Napisałeś ten tekst..."); //to nie zostanie napisane
dlugopis1.czyWysuniety = true;
dlugopis1.pisz("Wkład wysunięty?"); //to już zostanie napisane, bo wkład jest wysunięty
return 0;
}Jak widać powyżej konstruktor wstawiłem nad polem do którego odwołuję się w kodzie. Na kompilatorze GCC co prawda nie otrzymałem błędu ponieważ cała klasa jest jednym obiektem, a tworząc go (czyli w momencie uruchomienia konstruktora) pole jest już stworzone. Nie mniej tego typu zapis jest trochę nie logiczny i polecam go zamienić na taki:
class Dlugopis {
public:
bool czyWysuniety;
Dlugopis() {
czyWysuniety = false;
}
void pisz(string tekst) {
if(czyWysuniety)
cout << tekst;
}
};Pamiętajcie również o tym, że konstruktor musi znajdować się w sekcji publiczne ponieważ obiekty tworzymy poza klasą.
Nasz pierwszy obiektowy program ma już ręce i nogi.
Ćwiczenie
W ramach ćwiczeń polecam napisać coś podobnego, tworząc na przykład klasę Budzik, gdzie będziemy mieć metody takie jak podajGodzine(), ustawAlarm(), godzinaAlarmu(). Mogą one zwracać statyczny tekst, za wyjątkiem godzinaAlarmu() gdzie powinna być zwracana godzina ustawiona za pomocą metody ustawAlarm(). Dla osób bardziej ambitnych polecam napisanie sobie własnego stosu w C++, którego kod i sposób działania w Javie opisałem na łamach artykułu „Abstrakcyjne struktury danych: Stos„. Stos to po prostu obiekt (klasa), który oferuje „specyficzny” dostęp do danych.



// brak komentarzy — bądź pierwszy