Przypomnij sobie lekcję o strukturach. Klasa w języku C++, to po prostu struktura rozszerzona o dodatkowe czynności.
DEKLARACJE KLASY
#include <iostream>
using namespace std;
class nazwa_klasy
{
public:
int liczba;
char litera;
char napis[
256
];
};
int main(
int argc,
char* argv[])
{
system(
"PAUSE"
);
return EXIT_SUCCESS;
}
Jak widać klasę deklaruje się tak samo jak strukturę, tylko, że tu zamiast "struct", piszemy "class", potem nazwę deklarowanej klasy, następnie po słówku "public:" piszemy kolejne zmienne w klasie, tak samo jak w strukturze.
Różnica pomiędzy klasą a strukturą polega na tym, że wszystkie zmienne w strukturze są widoczne, natomiast w klasie są podziały na część publiczną, czyli widoczną na zewnątrz klasy i na prywatną, gdzie zmienne są widoczne tylko w danej klasie.
#include <iostream>
using namespace std;
class nazwa_klasy
{
public:
int liczba;
char litera;
private:
char napis[
256
];
};
int main(
int argc,
char* argv[])
{
system(
"PAUSE"
);
return EXIT_SUCCESS;
}
Teraz nasza klasa ma 2 podziały, na część publiczną i prywatną. Zmienne w części publicznej będą widoczne poza klasą, tak jak w strukturze, natomiast zmienne w części prywatnej nie będą widoczne na zewnątrz. W części publicznej mamy dwie zmienne, "liczba" i "litera", natomiast w sekcji prywatnej będzie łańcuch znaków "napis".
FUNKCJE W KLASIE
W klasie możemy umieszczać także funkcje, które będą wykonywały obliczenia, na obiektach w tej klasie.
#include <iostream>
using namespace std;
class nazwa_klasy
{
public:
void wypelnij_klase(
int licz,
char lit);
//deklarujemy funkcję w klasie
private:
int liczba;
char litera;
};
void nazwa_klasy::wypelnij_klase(
int licz,
char lit)
//ciało funkcji
{
liczba=licz;
litera=lit;
}
int main(
int argc,
char* argv[])
{
system(
"PAUSE"
);
return EXIT_SUCCESS;
}
Jak widać w klasie mamy funkcję, jednak jest tam tylko jej deklaracja, ciało funkcji powinniśmy umieścić poniżej, podając nazwę tej funkcji poza klasą, musimy przed nazwą zaznaczyć z jakiej klasy pochodzi funkcja, przy wypełnianiu ciała funkcji należy najpierw napisać nazwę klasy operator :: i po nim nazwę funkcji w tej klasie.
Nasza funkcja "wypelnij_klase" wypełnia zmienne w naszej klasie. Ponieważ zmienne są wartościami prywatnymi, nie można odwołać się do nich w funkcji "main" naszego programu, należy zrobić funkcje publiczne, które będą sterowały tymi zmiennymi.
TWORZENIE OBIETKÓW KLASY W PAMIĘCI
Na razie mówiliśmy sobie o deklaracji samej klasy i jej funkcji. Tak jak w strukturze, czym innym jest deklaracja klasy, a czym innym utworzenie takiej klasy w pamięci. Mając zadeklarowaną klasę i jej funkcje, możemy utworzyć sobie klasę w pamięci.
#include <iostream>
using namespace std;
class nazwa_klasy
{
public:
void wypelnij_klase(
int licz,
char lit);
//deklarujemy funkcję w klasie
private:
int liczba;
char litera;
};
void nazwa_klasy::wypelnij_klase(
int licz,
char lit)
//ciało funkcji
{
liczba=licz;
litera=lit;
}
int main(
int argc,
char* argv[])
{
nazwa_klasy Klasa;
//tworzymy w pamięci obiekt klasy nazwa_klasy
//w pamięci utworzony obiekt nazwya się Klasa
Klasa.wypelnij_klase(1,'a');
//używamy funkcji "wypełnij_klase" w obiekcie Klasa
//Klasa.liczba=0; - taki zapis jest niepoprawny, gdyż liczba jest składnikiem prywatnym,
//kompilatcja zakończy się błędem
cout<<
"Podaj tekst do zapisu\n"
;
system(
"PAUSE"
);
return EXIT_SUCCESS;
}
Aby wywołać funkcję w obiekcie w pamięci, lub odwołać się do zmiennej publicznej w utworzonej klasie, należy podać nazwę utworzonej klasy(w pamięci, nie definicję klasy) i po kropce wywołać zmienną lub funkcję. Należy pamiętać, że w ten sposób z poziomu programu(funkcji main) możemy odwoływać się do składników publicznych, prywatne może edytować dopiero taka funkcja. Dopiero funkcja wypelnij_klase, może edytować prywatne zmienne w klasie, bo jest jej częścią. Wywołując funkcję wypelnij_klase zmiennym prywatnym przypisaliśmy konkretne wartości.
KLASY W PRAKTYCE
Aby zobrazować jak wygląda programowanie z klasami podam przykład programu. Programowanie przy użyciu klas nazywa się programowaniem obiektowym, polega ono na modelowaniu w programie obiektów, takich jak w świecie rzeczywistym, a cały program składa się z takich niezależnych od siebie obiektów. Klasa jest właśnie takim obiektem w programie. Załóżmy, że chcemy mieć w programie książki, które będziemy przeglądać, w programowaniu obiektowym powinniśmy stworzyć właśnie takie książki jako klasy i pracować na nich, tak jakbyśmy pracowali z książką.
#include <iostream>
using namespace std;
class Ksiazka
//modelujemy ksiazke w naszym programie
{
private:
int ilosc_kartek_w_ksiazce;
//ilość kartek w naszej ksiazce
int przegladana_kartka;
//numer otwartej strony
public:
void Wypelnij_ksiazke(
int grubosc);
//funckja ta wypełnia ksiązke odpowiednimi wartościami
void Pokaz_strone();
//pokazuje na której stronie jest otwarta książka
bool Przekrec_kolejna_strone();
//przekręca o jedną stronę do przodu
bool Przekrec_poprzednia_strone();
//przekręca o jedną stronę do tyłu
bool Otworz_na();
//Funkcja otwiera na konkretnej stronie w książce
void Zamknij_ksiazke();
//Funkcja zamyka książkę
//Jak widać funkcje to akcje, jakie możemy wykonać z książką, tak jak z prawdziwą książką
};
void Ksiazka::Wypelnij_ksiazke(
int grubosc)
{
//wypełnia książkę wartościami, które podaje użytkownik w parametrach
if(grubosc<
1
) grubosc=
1
;
//sprawdzamy czy użytkownik nie podał grubości książki mniejszej od 1
//jeżeli tak to grubość książki ustawiamy na jedna stronę
ilosc_kartek_w_ksiazce=grubosc;
//parametrowi z grubością książki przypisujemy wartości w klasie
przegladana_kartka=0;
//przypisujemy przeglądanej kartce wartość 0, bo jeszcze nie otworzyliśmy książki,
//dzięki tej funkcji mamy grubość książki w zmiennej ilosc_kartek_w_ksiazce i zamkniętą książkę
}
void Ksiazka::Pokaz_strone()
{
//Funkcja wyświetla napis i informacją, która strona w kartce jest otwarta
if(przegladana_kartka==0)
//zakładamy ze gdy zmienna przeglądanej kartki wynosi 0, to książka jest zamknięta
{
cout<<
"Ksiazka jest zamknieta.\n"
;
//wyświetlamy napis że książka zamknięta
return;
//kończymy pracę funkcji
}
cout<<
"Otwarta jest strona numer: "
<<przegladana_kartka<<endl;
//wyświetla która strona jest otwarta
}
bool Ksiazka::Przekrec_kolejna_strone()
{
//funkcja, która przekręca kartkę
if(przegladana_kartka==ilosc_kartek_w_ksiazce)
return 0
;
//sprawdzamy czy nie jesteśmy już na ostatniej kartce, jeżeli jesteśmy, to zwracamy 0
przegladana_kartka++;
//przekręcamy kolejną kartkę
return 1
;
//zwracamy 1, co będzie oznaczać, że kartka została przekręcona poprawnie
}
bool Ksiazka::Przekrec_poprzednia_strone()
{
//funkcja, która przekręca na poprzednią stronę w książce
if(przegladana_kartka==
0
)
return 0
;
//sprawdzamy czy nie jesteśmy już na pierwszej kartce, jeżeli jesteśmy, to zwracamy 0,
//bo nie możemy przewrócić
przegladana_kartka--;
//przekręcamy do tyłu o jedną kartkę
return 1
;
//zwracamy 1, co będzie oznaczać, że kartka została przekręcona poprawnie
}
bool Ksiazka::Otworz_na()
{
//funkcja, która otwiera podaną stronę
cout<<
"Podaj numer otwieranej strony: "
;
int strona;
//zmienna pomocnicza
cin>>strona;
//użytkownik podaje numer strony
if((strona<1)||(strona>ilosc_kartek_w_ksiazce))
return 0
;
//najpierw musimy sprawdzić czy podana strona nie jest mniejsza od 1,
//oraz czy nie jest większa niż grubość książki, jeżeli tak zwracamy niepowodzenie, czyli 0
przegladana_kartka=strona;
return 1
;
}
void Ksiazka::Zamknij_ksiazke()
{
przegladana_kartka=
0
;
//Zamykamy książkę, czyli stronie przypisujemy 0
}
int main(
int argc,
char* argv[])
{
Ksiazka Przygodowa;
//tworzymy książkę "Przygodowa"
int zmienna;
//deklarujemy zmienną pomocniczą
cout<<
"Podaj grubosc ksiazki w stronach: "
;
cin>>zmienna;
//podajemy grubość książki do zmiennej pomocniczej
Przygodowa.Wypelnij_ksiazke(zmienna);
//funkcja wypełniania książki
//jako argument przekazujemy wartość zmiennej pomocniczej, która zawiera grubość książki
//w tym momencie mamy książkę o danej grubości i otwartej na stronie nr 0, czyli zamkniętej
//działanie programu zrobimy w pętli
bool wyjscie=
0
;
//zmienna na wyjscie z petli
char komenda;
//zmienna na komendę w naszym programie
while(wyjscie==
0
)
//dopóki wyjście będzie równało się 0, to wykonujemy pętlę
{
system(
"CLS"
);
//czyścimy ekran
cout<<
"Mozliwe komendy dla naszego programu:\n"
;
cout<<
"k - Przekrec na kolejna strone\n"
;
cout<<
"p - Przekrec na poprzednia strone\n"
;
cout<<
"s - Otworz na stronie numer\nz - Zamknij ksiazke\n"
;
cout<<
"w - Wyjdz z programu\n\n"
;
//wyświetlamy informacje na temat komend w naszym programie dla użytkownika
Przygodowa.Pokaz_strone();
//wyświetlamy informację o otwartej stronie
;
cout<<endl;
//przechodzimy do następnej linii
cin>>komenda;
//umieszczamy naszą komendę w zmiennej komenda
//teraz wybieramy akcję dla danej komendy
switch(komenda)
//kryterium jest komenda
{
case 'k':
//jeżeli podaliśmy k
if(!Przygodowa.Przekrec_kolejna_strone())
{
cout<<
"Jestesmy juz na ostatniej kartce!\n"
;
system(
"PAUSE"
);
}
//wykonujemy funkcję przekręcającą kartkę, jeżeli funkcja zwróci 0, to wyświetlamy odpowiedni napis
break;
case 'p':
if(!Przygodowa.Przekrec_poprzednia_strone())
{
cout<<
"Ksiazka jest juz zamknieta!\n"
;
system(
"PAUSE"
);
}
//jak poprzednio, tylko, że tutaj funkcja cofająca kartkę
break;
case 's':
if(!Przygodowa.Otworz_na())
{
cout<<
"Numer tej strony nie istnieje!\n";
;
system(
"PAUSE"
);
}
//wykonujemy funkcję otwierającą kartkę, jeżeli funkcja zwróci 0, to wyświetlamy odpowiedni napis
break;
case 'z':
Przygodowa.Zamknij_ksiazke();
//zamykamy książkę
break;
case 'w':
wyjscie=
1
;
//zmiennej wyjscie przypisujemy 1, więc działanie pętli się zakończy,
//a my wyjdziemy z programu
break;
default:
cout<<
"Nieznana komenda.\n"
;
//jeżeli użytkownik podał inną komendą wyświetl napis
system(
"PAUSE"
);
}
//opuszczamy instrukcję switch
}
//opuszczamy pętlę
return EXIT_SUCCESS;
//opuszczamy program
}
