Programowanie w C++ by-sa/ 3. 0/ legalcode.

C++/Wersja do druku 1 C++/Wersja do druku Programowanie w C++ Aktualna, edytowalna wersja tego podręcznika jest dostępna w Wikibooks, bibliotece wolnych podręczników pod adresem Całość tekstu jest objęta licencją CC-BY-SA 3.0 [1] i jednocześnie GNU FDL 1.2. Udziela się zezwolenia do kopiowania, rozpowszechniania lub modyfikacji tego dokumentu zgodnie z zasadami Licencji Creative Commons Uznanie autorstwa-na tych samych warunkach 3.0 Unported lub dowolnej późniejszej wersji licencji opublikowanej przez Creative Commons, która zawiera te same elementy co niniejsza licencja. Treść licencji dostępna jest pod adresem http:/ / creativecommons. org/ licenses/ by-sa/ 3. 0/ legalcode. Udziela się zezwolenia do kopiowania, rozpowszechniania lub modyfikacji tego dokumentu zgodnie z zasadami Licencji GNU Wolnej Dokumentacji w wersji 1.2 lub dowolnej późniejszej, opublikowanej przez Free Software Foundation; nie zawiera Sekcji Niezmiennych, bez Tekstu na Przedniej Okładce i bez Tekstu na Tylnej Okładce. Kopia licencji załączona jest w sekcji zatytułowanej "GNU Free Documentation License". Spis treści Wstęp 1. O języku C++ Opis i historia 2. O podręczniku Autorzy, źródła, jak czytać ten podręcznik Część 1: Podstawowe mechanizmy C++ 1. Przestrzenie nazw Wprowadzenie pojęcia przestrzeni nazw, przestrzeń nazw std 2. Zmienne Nowe sposoby deklaracji, kontrola typów w C++, nowe sposoby rzutowania 3. Referencje Porównanie ze wskaźnikami, zastosowanie do przekazywania argumentów do funkcji 4. Funkcje inline Krótki opis funkcji inline 5. Przeciążanie funkcji Po co i jak można przeciążać funkcje i jak tego nie da się robić 6. Zarządzanie pamięcią Jak w C++ dynamicznie zarządzać pamięcią z użyciem operatorów new i delete 7. Strumienie Obsługa strumieni wejścia i wyjścia, czytanie i pisanie do plików, obiekty std::istream i std::ostream

C++/Wersja do druku 2 Część 2: Podstawy programowania obiektowego 1. Czym jest obiekt Wprowadzenie pojęcia klasy i obiektu, autorekursja, kontrola dostępu 2. Konstruktor i destruktor Konstruktor, konstruktor kopiujący, destruktor 3. Dziedziczenie Dziedziczenie prywatne, publiczne i chronione 4. Składniki statyczne Atrybuty i metody statyczne Część 3: Zaawansowane programowanie obiektowe 1. Funkcje wirtualne Funkcje wirtualne i abstrakcyjne, wyjaśnienie polimorfizmu i dynamic_cast 2. Programowanie zorientowane obiektowo Wyjaśnienie idei programowania zorientowanego obiektowo 3. Obiekty stałe Jak tworzyć, możliwe niebezpieczeństwa, słowo kluczowe mutable 4. Przeciążanie operatorów Wprowadzenie przykładu klasy z kompletnym przeciążeniem operatorów 5. Konwersje obiektów Przeciążenie operatorów konwersji, konstruktor jako sposób konwersji, konstruktory typu explicit 6. Klasy i typy zagnieżdżone Tworzenie klas i typów zagnieżdżonych 7. Dziedziczenie wielokrotne Dziedziczenie wielokrotne, dziedziczenie wirtualne oraz problemy z nimi związane Część 4: Zaawansowane konstrukcje językowe 1. Obsługa wyjątków Obsługa wyjątków w C++, funkcje unexpected() i terminate() 2. Szablony funkcji Szablony funkcji 3. Szablony klas Szablony klas, programowanie uogólnione 4. Wskaźniki do elementów składowych Wykorzystnie wskaźników do elementów składowych klas

C++/Wersja do druku 3 Dodatek A: Biblioteka STL 1. Filozofia STL Jak skonstruowana jest biblioteka STL 2. String Korzystanie z łańcuchów znaków 3. Vector Korzystanie z wektorów 4. List & Slist Listy jedno- i dwukierunkowe 5. Set Korzystanie ze zbiorów 6. Map Korzystanie z odwzorowań 7. Stack Korzystanie ze stosu 8. Iteratory Korzystanie z iteratorów 9. Algorytmy w STL Jak działają algorytmy w STL 10. Inne klasy STL Krótkie omówienie pozostałych klas Dodatek B 1. Przykłady Przykłady kodu z komentarzem 2. Ćwiczenia Zadania kontrolne 3. Różnice między C a C++ Najważniejsze różnice między C a C++ Pozostałe 1. Indeks Indeks najważniejszych terminów 2. Zasoby Książki, linki do innych kursów i dokumentacji 3. Dla autorów Wskazówki dla osób pragnących pomóc w rozwoju podręcznika 4. Wersja do druku Całość książki na jednej stronie, gotowa do druku 5. Licencja Pełny tekst GNU Free Documentation license Wstęp

C++/Wersja do druku 4 O języku C++ C++ jest językiem wieloparadygmatowym, mającym korzenie w popularnym języku C. Na jego rozwój oddziaływało wiele języków, z których należy przede wszystkim wspomnieć Simulę i Adę. Programiści cenią go za połączenie bezkompromisowej wydajności programów wynikowych z zaawansowanymi mechanizmami umożliwiającymi programowanie na wysokim poziomie abstrakcji i kontrolę zależności między komponentami w wielkich projektach. C++ stara się zachować kompatybilność z językiem C, ale jednocześnie udostępnia szeroki wachlarz nowych mechanizmów, m.in: programowanie obiektowe z wielokrotnym dziedziczeniem i kontrolą dostępu, dynamiczną kontrolę typów i precyzyjne rzutowanie, programowanie generyczne (uogólnione) dzięki wykorzystaniu szablonów, przeciążanie funkcji i operatorów, obsługę sytuacji wyjątkowych i zarządzanie przestrzeniami nazw. Od ostatnio powstałych konkurentów, takich jak Java i C#, wyróżnia się traktowaniem typów zdefiniowanych przez użytkownika na równi z typami wbudowanymi. Niestety, to bogactwo możliwości skutkuje rozbudowaną składnią języka, stanowiąc problem nawet dla kompilatorów (żaden popularny kompilator nie jest w pełni zgodny z obowiązującym standardem języka; stan na 2010 rok). Nazwa C++ została zaproponowana przez Ricka Mascitti i wywodzi się z faktu, że w C wyrażenie zmienna++ oznacza inkrementację, czyli zwiększenie o jeden. Autorem i twórcą języka C++ jest duński programista Bjarne Stroustrup, pierwsza wersja pojawiła się w 1979. O podręczniku O podręczniku Podręcznik ten jest tworzonym na Wikibooks kursem języka C++. Początkowo pomyślany jako samodzielna jednostka, po dyskusji utracił część treści na rzecz podręcznika C i odtąd ma być jego w pewnym sensie przedłużeniem, bez powielania występujących tam podstaw. Tworzenie podręcznika Niniejszy kurs cały czas jest w fazie rozwojowej. Jako otwarty podręcznik może być edytowany przez każdego i każdy wkład będzie mile widziany. Przed wprowadzaniem poważniejszych zmian warto jednak przeczytać rozdział Dla autorów. Autorzy Znaczący wkład w powstanie podręcznika mają: Derbeth Felix Bibliografia ISO/IEC 14882:2003 Programming Languages C++ Jak czytać ten podręcznik Język C++ powstał jako wzbogacenie języka C o cechy obiektowe. Ten podręcznik został podobnie pomyślany: nie jako osobna całość, ale logiczne przedłużenie podręcznika C. Co prawda, oba kursy są niezależne, ale pisząc ten podręcznik staraliśmy się nie powtarzać informacji, które były już zawarte w poprzedniej książce. Nie znajdzie tu się więc objaśnienie, czym jest kompilator, jak działa i który kompilator wybrać, czym jest funkcja i zmienna oraz

C++/Wersja do druku 5 podobne podstawowe informacje. Czytelnikowi zostawiamy swobodę w tym, jak podejdzie do tego podręcznika, ale zalecamy jeden z przedstawionych dalej dwóch sposobów. Pierwszy z nich to dokładne przestudiowanie kursu C a następnie zaczęcie od pierwszej części tego podręcznika, gdzie pokazujemy, co C++ zmienia w składni i co oferuje nowego. Idąc dalej, czytelnik dojdzie do programowania obiektowego. Taki sposób jest co prawda bardziej pracochłonny i wymaga większego wysiłku, ale systematyczne podejście do nauki języka powinno zaowocować dobrym uporządkowaniem informacji i większym zrozumieniem filozofii obu języków. Możliwa jest też droga dla osób bardziej niecierpliwych. Należy wtedy szybko przejrzeć kilka początkowych rozdziałów podręcznika C, ominąć część pierwszą tego kursu i od razu zacząć od programowania obiektowego, w razie kłopotów zaglądając do Indeksu. Może to być dobra metoda dla osób zaznajomionych już z programowaniem, choć w C++ czyha na nieuważnych wiele pułapek, które trzeba nauczyć się omijać. Przestrzenie nazw Słowem wstępu Część 1 Podstawy języka Jeśli użyjemy dowolnej wyszukiwarki internetowej, to powinniśmy bez problemu znaleźć prosty, szablonowy kod napisany w C++, który wyświetla napis Hello World!, w tłumaczeniu na polski Witaj Świecie!. Spójrzmy na niego: #include <iostream> using namespace std; int main () cout << "Hello World!" << endl; return 0; Zaleca się używanie znaku nowej linii (\n) zamiast manipulatora wyjścia "endl". Chyba że jest to uzasadnione: endl wymusza opróżnienie bufora, ale na przykład przy wielokrotnym zapisie na dysk może to obciążyć jego pracę. Osoby, które już znają C, na pewno się domyślą, co mniej więcej się dzieje w tym kodzie. Najpierw, pokrótce omówimy, co ten program właściwie robi. Za pomocą #include <iostream> dołączyliśmy plik nagłówkowy do obslugi strumieni I/O, dzięki czemu możemy wypisywać dane na ekran (ściślej: na standardowe wyjście). Dodatkowo istnieje plik nagłówkowy iostream.h. Jest to jednak nagłówek niestandardowy, pomagający zachować wsteczną zgodność. int main( )... służy zdefiniowaniu funkcji głównej, która jest zawsze uruchomiana podczas startu naszego programu. Wyrażenie cout << umożliwia nam wypisywanie pewnych informacji. W naszym przypadku wypisaliśmy napis Hello World!, a następnie przedłużyliśmy to polecenie za pomocą operatora <<, i użyliśmy endl, który m.in. dodaje znak nowej linii. Za pomocą return 0 informujemy system, że program może zakończyć działanie bez zgłaszania błędów.

C++/Wersja do druku 6 Na koniec zostawiliśmy linię z kodem using namespace std. Aby wyjaśnić jej znaczenie, musimy omówić czym są przestrzenie nazw. Przestrzenie nazw Podczas pracy nad dużymi projektami, w których używa się wielu bibliotek z licznymi deklaracjami, możemy w końcu natknąć się na problem konfliktu nazw - gdy kilka obiektów, typów czy funkcji ma tę samą nazwę. Rozwiązaniem może być np. zamknięcie nazw w "zakresach", w celu oddzielenia ich. Z pomocą przychodzi nam mechanizm przestrzeni nazw. Przestrzeń nazw jest zatem zbiorem obiektów, która ogranicza dostęp do nich - oprócz nazwy obiektu niezbędne jest też wspomnienie, z której przestrzeni nazw chcemy go użyć, obchodząc tym samym problem konfliktu nazw. Spójrzmy na kolejny program, zmienioną wersję poprzedniego: #include <iostream> int main () std::cout << "Hello World!" << std::endl; return 0; Widzimy tu wyrażenie std:: pojawiające się przed cout i endl. Zapis ten oznacza, że wspomniane obiekty chcemy zaczerpnąć z przestrzeni std, a przy okazji nie obchodzi nas, czy są jakieś inne obiekty o takich nazwach. Jeśli jednak pominiemy wzmiankę o std::, pojawi się informacja o błędzie. W przestrzeni nazw std znajdziemy mnóstwo, a wręcz cały arsenał różnych narzędzi, począwszy od pewnych bardzo przydatnych funkcji, np. sortowania, wyszukiwania, a kończywszy na tak zwanych pojemnikach (kolekcjach), które pozwalają nam w łatwy sposób przechowywać pewne wartości. Oczywiście, aby mieć dostęp do tych narzędzi, musimy dołączyć odpowiedni plik nagłówkowy, używając do tego dyrektywy #include. Przykład pierwszy ze wstępu pokazał nam, że nie musimy za każdym razem odwoływać się do przestrzeni nazw, kiedy chcemy użyć znajdujących się w niej rzeczy. Używając using namespace PrzestrzenNazw, podpowiadamy kompilatorowi, w którym miejscu może szukać używanych przez nas obiektów i funkcji, abyśmy mogli swobodnie używać wszystkiego co się znajduje w danej przestrzeni nazw, tzn. bez dodatkowej wzmianki jak np. std::. Oczywiście nie musimy naraz "udostępniać" wszystkiego, co jest w danej przestrzeni nazw, możemy wykorzystać także pewne wybrane elementy. Używamy do tego operacji using PrzestrzenNazw::element. Zobaczmy przykład użycia tej operacji: #include <iostream> using std::endl; int main () std::cout << "Hello World!" << endl; return 0; Za pomocą using std::endl poinformowaliśmy kompilator, że będziemy mogli używać w kodzie endl i będziemy mieli na myśli właśnie to pochodzące z przestrzeni std. Nie wykonaliśmy tej operacji na elemencie

C++/Wersja do druku 7 cout (nie wstawiliśmy instrukcji using std::cout), więc musieliśmy go dalej poprzedzić nazwą przestrzeni. W dalszej części podręcznika będzie używany zapis z przedrostkiem std::. Tworzenie własnej przestrzeni nazw Przestrzeń nazw tworzymy za pomocą słowa kluczowego namespace, ograniczając jej zawartość klamrami. Możemy na przykład stworzyć przestrzeń nazw HelloWorld zawierającą funkcję hello( ): #include <iostream> namespace HelloWorld void hello () std::cout << "Hello World!" << std::endl; int main () HelloWorld::hello (); return 0; Oczywiście, gdybyśmy wstawili using HelloWorld::hello lub ogólnie using namespace HelloWorld przed funkcją main (a nawet wewnątrz tej funkcji), nie musielibyśmy odwoływać się jawnie do HelloWorld, wystarczyłoby samo hello( ). Co ciekawe, nie musimy zamieszczać zawartości naszej przestrzeni nazw w jednym, ciągłym bloku. Możemy rozbić to na kilka części: namespace Matematyka int dodaj (int a, int b) return a+b; int odejmij (int a, int b) return a-b; namespace Matematyka int pomnoz (int a, int b) return a*b;

C++/Wersja do druku 8 int podziel (int a, int b) return a/b; Wówczas wewnątrz przestrzeni nazw Matematyka znajdziemy wszystkie stworzone przez nas funkcje. Tworząc funkcję w przestrzeni nazw możemy wstawić samą deklarację, a potem w innym miejscu podać pełną definicję tej funkcji. Możemy na co najmniej dwa sposoby podać definicję pewnej funkcji - wewnątrz przestrzeni nazw lub poza nią, pisząc typ_zwracany PrzestrzenNazw::nazwa_funkcji( ), na przykład: #include <iostream> namespace Matematyka int dodaj (int a, int b); int odejmij (int a, int b); using namespace std; int main () cout << Matematyka::dodaj (10, 20) << endl; return 0; namespace Matematyka int dodaj (int a, int b) return a+b; int odejmij (int a, int b) return a-b; Jak wspomniano wcześniej, ostatnie dwie definicje funkcji moglibyśmy zapisać także w ten sposób: int Matematyka::dodaj (int a, int b)... int Matematyka::odejmij (int a, int b)...

C++/Wersja do druku 9 Przestrzeń nazw std Wróćmy ponownie do standardowej przestrzeni nazw, jaką jest std. Dzięki plikowi nagłówkowemu iostream możemy operować na standardowym wejściu i wyjściu. Zobaczmy jak wczytywać pewne wartości do zmiennych, używając do tego cin: #include <iostream> int main () int a, b; std::cout << "Podaj dwie liczby a i b" << std::endl; // wypisujemy komunikat i czekamy na wpisanie liczby a std::cout << "podaj a: "; std::cin >> a; // wypisujemy komunikat na wyjście i czekamy na wpisanie liczby b std::cout << "podaj b: "; std::cin >> b; // wypisujemy sumę tych dwóch liczb std::cout << "a+b= " << a+b << std::endl; return 0; Dzięki std::cin >> możemy wczytać pewną wartość do zmiennej. Zmienna ta nie musi być liczbą, może być też np. napisem. W C++ tekst (łańcuch znaków) będziemy często przechowywali w obiektach typu string (który także znajduje się w std). Do jego obsługi będziemy musieli dołączyć do projektu bibliotekę <string>. Spójrzmy na przykład: #include <iostream> #include <string> using std::cout; using std::cin; using std::endl; int main () std::string imie; std::string email; std::string informacja; // wczytujemy imię cout << "Podaj swoje imie: "; cin >> imie; // wczytujemy email

C++/Wersja do druku 10 cout << "Podaj swój email: "; cin >> email; informacja = imie + " (" + email + ")"; // suma (konkatenacja) napisów cout << "Witaj " << informacja << endl; informacja += " czyta ten napis"; cout << informacja << endl; return 0; Zauważmy, jak prosto się korzysta zmienną typu string (dla wtajemniczonych jest to pewna klasa). Jeśli chcemy dodać dwa napisy, wystarczy wykorzystać operator +. Możemy także wykorzystywać operator +=, jeśli chcemy dokleić do tekstu dodatkowy napis. Podając swoje imię jako Zdzichu, a e-mail jako zdzichu@zdzichowo.mars, zobaczymy wynik: Podaj swoje imie: Zdzichu Podaj swój email: zdzichu@zdzichowo.mars Witaj Zdzichu (zdzichu@zdzichowo.mars) Zdzichu (zdzichu@zdzichowo.mars) czyta ten napis Więcej o stringach można przeczytać w dodatku opisującym bibliotekę STL. Korzystanie z biblioteki standardowej C Ponieważ język C++ jest (w pewnym uproszczeniu) rozwinięciem C, w dalszym ciągu można korzystać z biblioteki standardowej C (tzw. libc). Ze względu na zachowanie wstecznej kompatybilności, umożliwiono korzystanie z niej tak jak wcześniej w C. #include <string.h> int main (int argc, char **argv) if (argc < 2) return -1; return strcmp (argv[0], argv[1]); Jednak dostępna jest też wersja libc przygotowana specjalnie dla C++. Pliki nagłówkowe są w niej inaczej nazywane, wszystkie funkcje znajdują się dodatkowo w przestrzeni nazw std. Tak więc powyższy program napisany w sposób właściwy dla C++ mógłby wyglądać następująco: #include <cstring> // zamiast <string.h> int main (int argc, char **argv) if (argc < 2) return -1; return std::strcmp( argv[0], argv[1]);

C++/Wersja do druku 11 Zauważmy, że: 1. dołączany plik nagłówkowy ma dodaną na początku literę c 2. dostęp do funkcji jest możliwy przez pośrednictwo przestrzeni nazw std Reguła ta dotyczy wszystkich plików, z których składa się biblioteka standardowa C. W swoich programach lepiej jest używać wersji przygotowanej dla C++: #include <cxxxxx>. Po pierwsze, dzięki przestrzeniom nazw unikniemy kolizji nazw z własnymi funkcjami. Po drugie, wersja ta ma wbudowaną obsługę wyjątków. Po trzecie, czasami libc przygotowana dla C wywołuje ostrzeżenia lub błędy kompilacji w kompilatorach C++. Można też w C++ używać klasycznych nazw (z C) (stdio.h, stdlib.h, string.h,...), ale czasami libc przygotowana dla C wywołuje ostrzeżenia lub błędy kompilacji. Zmienne Zanim przystąpisz do czytania tego rozdziału upewnij się, że opanowałeś już wiedzę z podręcznika C. Jest tu wykorzystywanych wiele odniesień i pojęć z tego języka. Deklarowanie zmiennych W języku C zmienne deklarowało się na początku bloku kodu (zwykle przed pierwszą instrukcją). W przeciwieństwie do C++ nie można było natomiast deklarować zmiennych np. w nagłówku pętli for. Poniższy przykład bez problemu powinien zadziałać w kompilatorach języka C++, natomiast starsze kompilatory C mogą go uznać za błędny: int main () for (int i = 0; i <= 10; ++i) // instrukcje... W C++ deklaracje zmiennych mogą znajdować się w dowolnym miejscu kodu w funkcji, nie obowiązuje już zasada z C nakazująca ich deklarowanie przed właściwym kodem funkcji: #include <iostream> using namespace std; int main () int i; cin >> i; int j = i*i; cout << j; return 0;

C++/Wersja do druku 12 Kontrola typów W C++ w stosunku do C została zaostrzona kontrola typów. Teraz za każdym razem, gdy przekażemy funkcji zmienną o innym typie dostaniemy błąd od kompilatora. Główna zmiana dotyczy wskaźników na typ void*. W C były one zupełnie bezkarne i można było przydzielać wskaźniki void* do każdych innych, w C++ są na równi z innymi typami. Teoretycznie kod napisany w C powinien zostać bez problemu skompilowany w kompilatorze C++, lecz istnieje kilka rozbieżności, które czasami to uniemożliwiają. Jedna z nich dotyczy właśnie typu void*. Kod w C, bez problemu skompilowany w kompilatorze tegoż języka: int* wskaznik = malloc (sizeof(int)); nie zostanie skompilowany w kompilatorze C++, z powodu zaostrzonej kontroli typów. Aby sprawić, że ten kod będzie się kompilować musimy go odrobinę zmodyfikować: int* wskaznik = (int*) malloc (sizeof(int)); Problem został rozwiązany przy użyciu rzutowania. Co to takiego? Odpowiedź znajdziesz w dziale poniżej. Rzutowanie W języku C rzutowanie wyglądało w następujący sposób: int zmienna_calkowita = (int)zmienna_rzeczywista; W C++ nadal można używać takiego rzutowania, jest ono nazywane "rzutowaniem w stylu C". Oprócz tego C++ oferuje "rzutowanie w stylu funkcyjnym": int zmienna_calkowita = int(zmienna_rzeczywista); które działa dokładnie tak samo. Oba zapisy mają jedną istotną wadę - ciężko wypatrzeć je w kodzie. Każde rzutowanie jest potencjalnym miejscem wystąpienia błędów. Jeśli byśmy chcieli przejrzeć kod źródłowy w poszukiwaniu wszystkich rzutowań, nie byłoby to łatwe, przez co usuwanie błędów z programu w stylu języka C jest utrudnione. C++ wprowadza inny sposób zapisu, który od razu rzuca się w oczy. Dodatkowo rzutowanie podzielono na cztery typy: static_cast proste rzutowanie const_cast rzutowanie ze zmiennych z modyfikatorem const i volatile na zmienne bez tych modyfikatorów reinterpret_cast niebezpieczne rzutowania, które zmieniają zupełnie sens interpretacji bitów w zmiennych dynamic_cast rzutowanie wskaźników na obiekty Ostatnie z tych rzutowań będzie opisane później, w rozdziale../funkcje wirtualne/. Powodem takiego podziału jest potrzeba zwiększenia bezpieczeństwa przez wyeliminowanie pomyłek. Jak to działa? Jeśli chcielibyśmy dokonać pewnego rodzaju rzutowania operatorem, który nie jest do niego przewidziany, kompilator zgłosi nam błąd. Dodatkowo, jeśli podejrzewamy, że jakiś błąd w działaniu programu wynika z rzutowania, najczęściej chodzi nam o rzutowanie konkretnego rodzaju, zatem podział rzutowań ułatwia znajdywanie takich błędów. Nowych operatorów rzutowania używa się w następujący sposób:

C++/Wersja do druku 13 int zmienna_całkowita = static_cast<int>(zmienna_rzeczywista); podając w nawiasach ostrych typ, na który rzutujemy. Omówimy teraz dłużej pierwsze trzy z nowych rzutowań. Static_cast Operator static_cast zapewnia wysoki poziom bezpieczeństwa, gdyż widząc static_cast kompilator używa całej swojej mądrości, żeby zagwarantować jak najsensowniejszy rezultat rzutowania, w razie potrzeby zmieniając reprezentację wartości poddanej rzutowaniu. Przykładowo przy rzutowaniu zmiennej typu int na float, bity wewnętrznej reprezentacji zostaną zmienione, tak aby reprezentowały tę samą wartość matematyczną, ale według formatu używanego dla float. Static_cast służy w szczególności do: Konwersji podstawowych typów liczbowych, np. int na float. Konwersji zdefiniowanych przez użytkownika. Konwersji wskaźnika na obiekt klasy pochodnej na wskaźnik na obiekt klasy podstawowej (tak zwane rzutowanie do góry hierarchii dziedziczenia). Konwersji wskaźnika na obiekt klasy podstawowej na wskaźnik na obiekt klasy pochodnej (tak zwane rzutowanie w dół hierarchii). Są też inne zastosowania, np. rzutowanie zmiennej za pomocą wyrażenia static_cast<void>(nazwa_zmiennej), które na niektórych kompilatorach pozwala uniknąć ostrzeżenia o nieużywaniu tej zmiennej. Nie przejmuj się, jeżeli trzy ostatnie punkty powyższej listy są niezrozumiałe. Staną się zrozumiałe po przeczytaniu rozdziału o dziedziczeniu i definiowaniu konwersji typów. Ważny jest morał z przytoczenia tych zastosowań, a mianowicie fakt, że static_cast służy do najczęściej wykorzystywanych, zdefiniowanych przez standard języka i bezpiecznych rzutowań. Czwarty punkt na powyższej liście przypomina jednak o tym, że nie zawsze rzutowanie static_cast jest bezpieczne w czasie wykonania programu. Wyjaśnienie dla zaawansowanych: Jeśli wykonamy rzutowanie w dół na typ, który nie jest zgodny z rzeczywistym (dynamicznym) typem obiektu, rezultatem może być wysypanie się programu. Do czego static_cast nie służy: Do rzutowania wskaźników na różne typy, jeśli nie ma specjalnie zdefiniowanej konwersji między tymi wskaźnikami. Przykładowo nie skompiluje się static_cast<int*>(i), jeśli zmienna i jest typu unsigned int* Nie uda się też rzutowanie ze wskaźnika na typ stały (z modyfikatorem const) na wskaźnik na typ niestały. Do dynamicznego sprawdzania, czy rzutowanie mogłoby się powieść (czy ma sens). Nie miałoby to sensu, bo dla static_cast sposób rzutowania jest ustalany w czasie kompilacji. Zresztą nie ma żadnej informacji o błędzie, którą można by było sprawdzić. Przykłady poprawnego użycia static_cast: #include <iostream> int main () int liczba = 5, liczba2 = 2; std::cout << "5/2 int(bez rzutowania): " << liczba/liczba2 << std::endl; std::cout << "5/2 float(static_cast): "

C++/Wersja do druku 14 << static_cast<float>(liczba)/static_cast<float>(liczba2) << std::endl; return 0; Przykłady niepoprawnego użycia static_cast: #include <iostream> int main () std::string str = "ciag"; std::cout << "string --> char: " << static_cast<char>(str) << std::endl; return 0; Inne Cechy static_cast Standard języka stwierdza również, że wyrażenia, które nie dokonują żadnej konwersji mogą być również opisane operatorem static_cast, np. int i = static_cast<int>(8);. Takie static_cast może być bezpiecznie usunięte z kodu, należy jednak uważać na usuwanie go z kodu generycznego, korzystającego z szablonów. W powyższym wstępie i przykładach wszędzie, gdzie jest mowa o wskaźnikach, można by również mówić o referencjach. Obowiązują je te same reguły. Należy pamiętać, że działanie rzutowania static_cast zależy tylko od takich informacji o typach, które są dostępne czasie kompilacji. Stąd słowo "static" w "static_cast". Kompilator nie dodaje "z własnej inicjatywy" kodu binarnego, więc static_cast można używać również w tzw. wąskich gardłach programu. Poprzednie zdanie celowo używa wyrażenia w cudzysłowie, bo jakiś kod oczywiście jest dodawany przez kompilator. Zazwyczaj jest to jednak tylko zmiana reprezentacji liczby lub wywołanie zdefiniowanej przez użytkownika (czyli z naszej inicjatywy) funkcji konwertującej. reinterpret_cast #include <iostream> using namespace std; int main(void) typedef unsigned long long ULL; typedef unsigned int UI; ULL a = 137438953600; //Liczba a w pamięci komputera: //00000000000000000000000000100000 //00000000000000000000000010000000 ULL* wsk_a_ll = &a; //ULL* wsk_a_int = static_cast<ui*>(&a); //błąd kompilatora - niedozwolone rzutowanie static_cast UI* wsk_a_int = reinterpret_cast<ui*>(&a); cout << *wsk_a_ll << "\n" << wsk_a_int[0] << " " << wsk_a_int[1] << "\n";

C++/Wersja do druku 15 return 0; Wyjście programu: 137438953600 128 32 W powyższym przykładzie próbujemy udowodnić, że dowolny zaalokowany obszar pamięci możemy potraktować jako tablicę, a interpretacja danych zależy od tego, jaki jest typ wskaźnika, którym się posługujemy; tutaj kolejno (long long *) oraz (int *). Stosowane jest rzutowanie typu "reinterpret_cast", ponieważ "static_cast" skutkuje błędem kompilacji. Samo rzutowanie jest niecodzienne i udowadnia, że "reinterpret_cast" należy używać jedynie w uzasadnionych okolicznościach. Ćwiczenia #include <iostream> int main (int argc, char *argv[]) int liczba, liczba2; std::cin >> liczba >> liczba2; double wynik = liczba / liczba2; std::cout << wynik << std::endl; return 0; Po uruchomieniu powyższego programu i podaniu wejścia 5 2 Otrzymamy 2 Dlaczego jako wynik wyświetlana jest liczba 2 a nie 2.5? Rozwiąż problem przy użyciu rzutowania.

C++/Wersja do druku 16 Referencje Czym jest referencja? Referencja w swym działaniu przypomina wskaźniki. Różnica polega jednak na tym, że do referencji można przypisać adres tylko raz, a jej dalsze używanie niczym się nie różni od używania zwykłej zmiennej. Operacje jakie wykona się na zmiennej referencyjnej, zostaną odzwierciedlone na zmiennej zwykłej, z której pobrano adres. Można by pokusić się o stwierdzenie, że: Referencja jest inną nazwą danej zmiennej. Deklaracja referencji Referencje deklaruje się jak zmienne z podaniem znaku &: TypDanych & referencja Taki zapis byłby możliwy w liście argumentów funkcji, jednak w ciele funkcji referencja musi być od razu zainicjalizowana. Zapisujemy do niej adres innej zmiennej (robi się to trochę inaczej niż w wypadku wskaźników): TypDanych & referencja = innazmienna; Od tej pory można używać obu tych zmiennych zamiennie. Poniższe przypisania dadzą więc ten sam efekt: innazmienna = 9; referencja = 9; Zobaczmy działanie referencji na konkretnym przykładzie: int i=0; int &ref_i=i; cout << i; // wypisuje 0 ref_i = 1; cout << i; // wypisuje 1 cout << ref_i; // wypisuje 1 Porównajmy to z sytuacją, gdybyśmy użyli wskaźników: int i=0; int * wsk_i=&i; cout << i; // wypisuje 0 *wsk_i = 1; cout << i; // wypisuje 1 cout << *wsk_i; // wypisuje 1 Zauważmy, o ile wygodniejsze jest użycie referencji. Nie musimy ani pobierać adresu zmiennej (&i) by przypisać go do referencji ani też używać gwiazdki by dostać wskazywaną wartość. Jeszcze jedną różnicą ze wskaźnikami jest ograniczenie, że referencji po przypisaniu nie można przestawić na inną zmienną. Referencja musi też być zainicjalizowana w momencie utworzenia:

C++/Wersja do druku 17 int a,b; int *wsk_a=&a, *wsk_b=&b; int &ref_a=a, &ref_b=b; int &ref_c; // kompilator nie zezwoli na to - referencja niezainicjalizowana wsk_b = &a; // ok ref_b = &a; // tak się nie da Przykład przypomina też, że analogicznie jak w przypadku wskaźników znak & nie łączy się z typem tylko ze zmienną i przy deklarowaniu kilku referencji na raz trzeba wstawiać & przed każdą z nich: int &ref_x = x, &ref_y = y; char *wsk_1, *wsk2; // wskazniki // referencje Stałe referencje Możliwe jest zadeklarowanie referencji do obiektów stałych - wtedy obiektu, do którego odnosi się referencja nie będzie można zmienić. int i=0; const int &ref_i=i; cout << ref_i; // wypisze 0 ref_i = 1; // kompilator nie pozwoli na to i zgłosi błąd Powody, dla jakich możemy chcieć używać stałych referencji są analogiczne jak dla stałych wskaźników. Przekazywanie argumentów przez referencję Aby w C zmodyfikować parametr przekazywany do funkcji, musieliśmy używać wskaźników. C++ proponuje bezpieczniejszą i wygodniejszą w użyciu metodę - przekazywanie przez referencję. Różnica między przekazywaniem przez referencję a przekazywaniem przez wskaźnik jest taka jaka miedzy referencjami i wskaźnikami, nie ma tu żadnej rewolucji. Przykład zastosowania pokazany jest poniżej: void nie_zwieksz (int i) ++i; // tak naprawdę funkcja nie robi nic, bo zmieniona zostaje tylko lokalna kopia void zwieksz_c (int *i) ++(*i); // ta funkcja jest napisana w stylu C void zwieksz_cpp (int& i) ++i; // ta funkcja wykorzystuje możliwości C++ int main () int a=0, b=0, c=0; nie_zwieksz (a);

C++/Wersja do druku 18 zwieksz_c (&b); zwieksz_cpp (c); cout << a << " " << b << " " << c; // wypisze "0 1 1" return 0; Funkcje inline Funkcje inline jak można by się domyśleć z nazwy są funkcjami "w linii" w C++ znaczy to, że kompilator widząc że funkcja jest inline w miejsce jej wywołania nie wstawia jak w normalnym przypadku wskaźnika do tej funkcji w pamięci, lecz wpisuje jej kod w miejsce jej wystąpienia. Takie funkcje dalej jednak występują w pamięci komputera, dzięki czemu możemy tworzyć do nich wskaźniki i używać ich jak w przypadku zwykłych funkcji. Użycie funkcji inline: inline int dodaj (int, int); //deklaracja int main () int a, b, c; c = dodaj (a,b); return 0; inline int dodaj (int a,int b) //definicja return a+b; Rzeczywiste działanie: int main () int a, b, c; c = a+b; //podstawianie kodu funkcji return 0; Ma to zastosowanie, gdy zależy programiście na szybkości działania programu. Status inline zazwyczaj dodaje się krótkim funkcjom, nie mającym więcej niż kilkanaście linijek kodu. Czasami gdy kompilator uzna, że nasza funkcja jest zbyt długa lub wywołuje się rekurencyjnie ignoruje nasze inline. Gdy chcemy wymusić takie zachowanie to używamy np. forceinline dla MS Visual C++. Funkcja składowa klasy zostaje natomiast automatycznie uznana za inline jeśli napiszemy jej kod bezpośrednio po jej deklaracji we wnętrzu klasy. Warto dodać że słowo inline jest słowem kluczowym w C++. Teoretycznie makroinstrukcje języka C mają dość podobne działanie, lecz funkcje inline mają nad nimi kilka przewag:

C++/Wersja do druku 19 czytelność makra języka C są znacznie mniej czytelne i są tak jakby "czarną owcą" w kodzie, gdyż są wplecione między różnorakie funkcje, które stanowią większość kodu, od których znacznie różnią się zapisem. konwersja argumentów jako, że funkcja inline imituje zwykłą funkcję, posiada argumenty z kontrolą typów, dzięki czemu inni programiści mogą z nich łatwiej korzystać w stosunku do makroinstrukcji. argumenty jako zmienne w przypadku makroinstrukcji argumenty nie są traktowane jako zmienne; to co przekażemy jako argument, jest po prostu kopiowane w miejsca użycia danego argumentu w kodzie makroinstrukcji. Funkcje inline posiadają argumenty, które są zmiennymi, co wyklucza wiele błędów. Gdzie tu jest haczyk? Otóż jako, że kod funkcji jest wstawiany w miejsce wywołania, to jeśli wywołamy tę funkcję w 3 miejscach, dostaniemy 3 kopie kodu tejże funkcji. Jeśli przesadzimy i będziemy dodawać przedrostek inline do zbyt wielu funkcji (zwłaszcza tych dużych i często wywoływanych), plik wykonywalny może urosnąć do niebotycznych rozmiarów (co dodatkowo przedłuża czas jego uruchamiania). Przeciążanie funkcji W języku C++ możliwe jest utworzenie kilku różnych funkcji, które posiadają tę samą nazwę. Takie funkcje muszą różnić się od siebie ilością lub typem argumentów. Dzięki temu kompilator będzie wiedział dokładnie, którą funkcję należy wywołać. Takie funkcje nazywamy przeciążonymi (czasem również przeładowanymi). Przeciążanie (przeładowanie) funkcji to zabieg polegający na utworzeniu kilku funkcji o tej samej nazwie, nazywanych funkcjami przeciążonymi. Takie funkcje muszą różnić się liczbą lub typem argumentów przekazywanych do tej funkcji, dodatkowo mogą różnić się zwracanym typem. Oto przykłady funkcji przeciążonych: void funkcja (int); void funkcja (std::string); void funkcja (std::string, std::string); // int funkcja (int); //niedozwolone, funkcje różnią się tylko zwracanym typem int funkcja (bool); //dozwolone Czasami kompilator może zabronić przeładowania, gdy uzna, że typy argumentów są zbyt podobne. Może tak się dziać na przykład w przypadku, gdy: użyjemy typu const T i T, użyjemy argumentów domyślnych. void funkcja (int arg1, int arg2 = 0); void funkcja (int arg1); //to ta sama funkcja, zostanie zgłoszony błąd Kompilator obsługuje przeciążanie przez dodanie do nazwy każdej z przeciążonych funkcji specjalnego identyfikatora, który związany jest z liczbą i typem argumentów - tak więc po etapie kompilacji wszystkie funkcje mają unikalne nazwy.

C++/Wersja do druku 20 Zastosowanie Przeciążenie funkcji stosuje się przy np. potęgowaniu: int pot (int, int); double pot (double, int); void pot (int&, int); int pot (int podstawa, int wykladnik) int wynik = 1; for (int i = 0; i < wykladnik; ++i) wynik = podstawa*wynik; return wynik; // przeładowana funkcja I: zwraca inny typ danych i są inne parametry double pot (double podstawa, int wykladnik) double wynik = 1; for (int i = 0; i < wykladnik; ++i) wynik = podstawa*wynik; return wynik; // przeładowana funkcja II: nie zwraca danych tylko modyfikuje podstawę która jest podana przez referencję void pot (int& podstawa, int wykladnik) int wynik = 1; for (int i = 0; i < wykladnik; ++i) wynik = podstawa*wynik; podstawa = wynik; Argumenty domyślne Pierwszym sposobem przeładowania są argumenty domyślne. Deklaracja funkcji wygląda tak: int potega (int podstawa, int wykładnik = 2); W tym przypadku, kiedy funkcje wywołamy poprzez potega(2), zostanie dodany parametr domyślny. Będzie to więc znaczyło to samo, co potega(2, 2). Nie możemy już jednak przeciążyć tej funkcji poniższą: int potega (int podstawa) return podstawa*podstawa;

C++/Wersja do druku 21 W tym przypadku, gdy podamy jeden argument, kompilator nie będzie mógł określić o którą funkcję nam chodzi - dwuargumentową z jednym argumentem domyślnym, czy zwykłą jednoargumentową. Typ argumentów Czasem możemy chcieć, by funkcja zachowywała się zależnie od tego, jakie argumenty jej dano. Załóżmy, że piszemy własną bibliotekę do obsługi standardowego wyjścia stdout. Chcemy zrobić funkcję wypisującą różne typy danych, w tym typ łańcuchów C++. void pisz (char); void pisz (std::string); void pisz (void); void pisz (char a) printf ("%c", a); void pisz (std::string a) printf ("%s", a.c_str()); void pisz () printf ("\n"); Uwaga! Zwróćmy uwagę na wywołanie printf("%s", a.c_str()). Należy pamiętać, że pole %s oczekuje łańcucha znaków typu char*. Nie obsłuży zatem typu string, dlatego posługujemy się funkcją c_str() zwracającą napis jako tablicę char. Szablony funkcji W C++ dostępne są szablony. Wyobraź sobie sytuację: programista pisze funkcję obsługującą sporo typów danych. Możemy rozwiązać to przez kopiowanie funkcji w kodzie. jednak byłoby to dość uciążliwe. Możemy to zrobić krócej: template <typename T> T nazwafunkcji (argumenty typu T) //do funkcji można przekazać dowolny typ danych

C++/Wersja do druku 22 Zarządzanie pamięcią W języku C++ do alokowania pamięci służy operator new a do zwalniania - delete. W C++ można również stosować funkcje malloc i free, jednak należy być ostrożnym. Najczęstszym błędem jest mieszanie operatorów new i delete z funkcjami malloc i free, np. zwalnianie pamięci zaalokowanej przez new przy pomocy free. Rozważmy prosty przykład. Załóżmy, że chcemy stworzyć wektor 10 liczb typu całkowitego. Możemy to zrobić na dwa sposoby. W stylu znanym z języka C: int *wektor = (int*) malloc (sizeof(int)*10); free (wektor); Albo w stylu C++: int *wektor = new int[10]; delete [] wektor; Od razu widać, że drugi zapis jest łatwiejszy i przyjemniejszy w użyciu. To jest podstawowa zaleta operatora new - krótszy zapis. Wystarczy wiedzieć jakiego typu ma być obiekt, który chcemy powołać do życia, nie martwiąc się o rozmiar alokowanego bloku pamięci. Za pomocą operatora new można również tworzyć tablice wielowymiarowe: int **wektory = new int *[5]; for (int i = 0; i < 5; ++i) wektory[i] = new int [10]; W ten sposób stworzono tablicę dwuwymiarową którą statycznie zadeklarowalibyśmy jako: int wektory[5][10]; Jenak w przeciwieństwie do int wektory[5][10], która jest tablicą dwuwymiarową, nasze int **wektory jest tablicą tablic i może być rozrzucone po całej pamięci. Ilość elementów poszczególnych wymiarów nie musi być jednakowa. Można np zadeklarować tablicę taką: int **wektory = new int *[2]; wektory[0] = new int [5]; wektory[1] = new int; Przy takiej deklaracji pierwszy wiersz ma 5 elementów (tablica) a drugi to jeden element. Deklaracja tablic o większej ilości wymiarów przebiega podobnie: int ***wektory; // deklarujemy tablicę 3-wymiarową wektory = new int **[5]; // pierwszy wymiar wektory[0] = new int *[10]; // pierwszy element pierwszego wymiaru wektory[1] = new int *[3]; // drugi element pierwszego wymiaru... wektory[0][0] = new int [3] // wymiar I = 0 -> wymiar II = 1 -> 3 elementy(tablica) wektory[0][1] = new int [5] // wymiar I = 0 -> wymiar II = 3 -> 5 elementów(tablica) wektory[1][0] = new int; // wymiar I = 1 -> wymiar II = 2 -> 1 element... Stosując ten sposób, ogólnie można deklarować tablice n-wymiarowe bez większego problemu. Usuwanie tablic wielowymiarowych przebiega podobnie jak jednowymiarowych, z tą różnicą, że usuwanie zaczynamy od

C++/Wersja do druku 23 "najgłębszego" wymiaru: delete wektory[1][0]; delete [] wektory[0][1]; delete [] wektory[0][0]; // II wymiar delete [] wektory[0]; delete [] wektory[1]; // I wymiar delete [] wektory; // kasujemy pojedynczą zmienną Zwrócić uwagę trzeba na dwie rzeczy: delete [] używamy dla zmiennych tablicowych, a delete dla pojedynczych zmiennych Kolejność zwalniania wymiarów jest odwrotna niż ich tworzenia Drugą zaletą jest fakt, że przy okazji alokacji pamięci możemy wywołać odpowiedni konstruktor inicjując wartości zmiennych obiektu, np. Test *test = new Test(1,2); zakładając, że obiekt Test posiada dwie zmienne typu całkowitego i zdefiniowany konstruktor Test(int,int). Kolejną korzyścią jest możliwość przeciążania. Jednak to już jest temat na inny rozdział. Czym jest obiekt? Część 2 Podstawy programowania obiektowego Aby odpowiedzieć na pytanie zadane w temacie, zadajmy sobie inne: Co nazywamy obiektem w świecie rzeczywistym? Otóż wszystko może być obiektem! Drzewa, zwierzęta, miasta, auta, ludzie... W programowaniu również obiektem może być dowolny twór, o jakim pomyślimy. Tworząc "świat programu" można stworzyć obiekt, którego użycie będzie bardziej "namacalne" od szeregu parametrów, porozrzucanych w różnych zmiennych. To różni programowanie strukturalne od programowania obiektowego. Projekt i twór klasa i obiekt Zanim stworzymy jakiś obiekt, trzeba ustalić czym ten obiekt będzie. W zależności od tego, czy chcemy stworzyć wirtualny samochód, czy samolot, należy określić dwie rzeczy: jakie właściwości będzie miał ten obiekt, jakie będzie miał metody działania. W związku z tym, przed stworzeniem jakiegokolwiek obiektu należy przedstawić kompilatorowi jego projekt(wzorzec), czyli określić jego klasę. Klasa to byt programistyczny określający jakie właściwości i metody będą miały obiekty, które zostaną utworzone na jej podstawie. Jednak sam projekt nie sprawi jeszcze, że dostaniemy obiekty (to tak jakby po narysowaniu projektu domu chcieć zamieszkać na kartce papieru :-)). Trzeba jeszcze obiekt utworzyć, co oznacza po prostu deklarację obiektu na podstawie pewnej klasy:

C++/Wersja do druku 24 NazwaKlasy MojObiekt; Wygląda to jak deklaracja zwykłej zmiennej i tak jest w istocie w C++ tworząc klasę definiuje się nowy typ danych. Podobnie jak w przypadku zmiennych, można utworzyć wiele obiektów danej klasy. Definicja klasy Ogólny szablon definiowania klas w C++ wygląda następująco: class NaszaNazwaKlasy... // pola i metody składowe klasy ; Po słowie kluczowym class następuje nazwa naszej klasy (prawidła jej nazywania są takie same jak dla zmiennych). W nawiasach klamrowych umieszcza się definicje składowych klasy: pól i metod określając dla nich specyfikatory dostępu. Należy pamiętać o średniku za klamerką zamykającą definicję klasy. Oto przykładowa definicja klasy: class NazwaKlasy public: //pola i metody są publicznie dostępne //definiowanie pól int poleint; float polefloat; //deklarowanie metod int Metoda1(); void Metoda2(); ; //pamiętaj o średniku! Użycie klasy Sama definicja klasy nie wystarczy, aby uzyskać dostęp do jej składowych. Należy stworzyć obiekt. Można przyjąć, że obiekt to zmienna typu klasowego. Deklaracja obiektu: NazwaKlasy Obiekt; Dostęp do pól i metod uzyskuje się operatorem (.): Obiekt.poleInt = 0;//przypisanie wartości polom Obiekt.poleFloat = 9.04; Obiekt.Metoda1();//wywołanie metody obiektu W przypadku deklaracji wskaźnika do obiektu: NazwaKlasy *ObiektWsk = new NazwaKlasy; Analogicznie jak w przypadku wskaźników na struktury operatorem dostępu do pola/metody klasy poprzez wskaźnik do obiektu staje się ->:

C++/Wersja do druku 25 ObiektWsk->poleInt = 0; //przypisanie wartości polom ObiektWsk->poleFloat = 9.04; ObiektWsk->Metoda1(); //wywołanie metody obiektu Należy pamiętać o zniszczeniu obiektu przed zakończeniem działania programu (lub kiedy nie jest nam już potrzebny): delete ObiektWsk; Przykład Stwórzmy klasę kostki do gry: class Kostka public: unsigned int wartosc; unsigned int maks; void Losuj(); ; Po definicji klasy, zdefiniujmy jeszcze metodę Losuj() zadeklarowaną w tej klasie: void Kostka::Losuj() wartosc = rand()%maks + 1; Warto zwrócić uwagę w jaki sposób się to robi. Nazwą metody dowolnej klasy jest NazwaKlasy::NazwaMetody. Poza tym aby uzyskać dostęp do pól klasy, w której istnieje dana metoda nie stosuje się operatora wyłuskania. Po tym można napisać resztę programu: int main() Kostka kostkaszescienna; //utworzenie obiektu kostkaszescienna.maks = 6; //określenie maksymalnej ilosci oczek kostkaszescienna.losuj(); //losowanie cout << "Wylosowano:" << kostkaszescienna.wartosc << endl;//wypisanie wyniku return 0; Autorekursja Wskaźnik this umożliwia jawne odwołanie się zarówno do atrybutów, jak i metod klasy. Poniższy program wymusza użycie wskaźnika this, gdyż nazwa pola jest taka sama jak nazwa argumentu metody wczytaj: #include <iostream> class KlasaThis int liczba; public: void wczytaj(int liczba) this->liczba=liczba; void wypisz() cout << liczba <<endl;

C++/Wersja do druku 26 ; int main() KlasaThis ObiektThis; ObiektThis.wczytaj(11); ObiektThis.wypisz(); return 0; Kontrola dostępu Istnieją trzy specyfikatory dostępu do składowych klasy: private (prywatny) - dostępne tylko z wnętrza danej klasy i klas/funkcji zaprzyjaźnionych. protected (chroniony) - dostępne z wnętrza danej klasy, klas/funkcji zaprzyjaźnionych i klas pochodnych. public (publiczny) - dostępne dla każdego. Jeśli sekwencja deklaracji składowych klasy nie jest poprzedzona żadnym z powyższych specyfikatorów, to domyślnym specyfikatorem (dla kompilatora) będzie private. Dzięki specyfikatorom dostępu inni programiści mają ułatwione korzystanie z utworzonej przez nas klasy, gdyż metody i pola, których nie powinni modyfikować, bo mogłoby to spowodować niepoprawne działanie obiektu, są oznaczone jako private lub protected i nie mogą z nich korzystać. Funkcje, które zapewniają pełną funkcjonalność klasy oznaczone są jako public i tylko do nich ma dostęp użytkownik klasy (do protected również, ale z ograniczeniami). Oto zmodyfikowany przykład z kostką, który zobrazuje cele kontroli dostępu: class Kostka public : void Losuj(); void Wypisz(); int DajWartosc(); void ZmienIloscScian(unsigned argmax); protected: unsigned wartosc; unsigned max; ; int Kostka::DajWartosc() return this->wartosc; void Kostka::ZmienIloscScian(unsigned argmax) if(argmax> 20) max = 20; else max = argmax;

C++/Wersja do druku 27 Zmodyfikowana klasa zezwala tylko na kostki maksymalnie dwudziestościenne. Ręczne modyfikacje zmiennej max są zabronione, można tego dokonać jedynie poprzez funkcję ZmienIloscScian, która zapobiega przydzieleniu większej ilości ścianek niż 20. Prywatny jest też atrybut wartość. Przecież nie chcemy aby była ona ustawiona inaczej niż przez losowanie! Dlatego możemy udostępnić jej wartość do odczytu poprzez metodę DajWartosc(), ale modyfikowana może być tylko na skutek działania metody Losuj(). Ćwiczenia 1. Napisz klasę reprezentującą człowieka. Musi on być opisany przy pomocy: imienia, nazwiska, płci, wieku, partnerki/partnera(jako wskaźnik). 2. Rozwiń klasę napisaną w 1. ćwiczeniu dodając ograniczenie, między partnerami nie może być większa niż 25% wieku starszej z nich. 3*. Jeśli zaznajomiłeś się z wektorami, dodaj kolejny parametr opisujący ludzi - zainteresowania, dodaj odpowiednią funkcję do dodawania nowych zainteresowań do listy oraz funkcję porównującą zainteresowania obu ludzi i zwracającą procent identycznych zainteresowań. Konstruktor i destruktor Teoria Wstęp Pisząc klasy każdy kiedyś dotrze do momentu, w którym będzie odczuwał potrzebę napisania funkcji wykonującej jakieś niezbędne instrukcje na początku lub na końcu istnienia obiektu. W takim momencie programista powinien sięgnąć po dwa niezwykle przydatne narzędzia: konstruktory i destruktory. Konstruktor Konstruktor jest to funkcja w klasie, wywoływana w trakcie tworzenia każdego obiektu danej klasy. Funkcja może stać się konstruktorem gdy spełni poniższe warunki Ma identyczną nazwę jak nazwa klasy Nie zwraca żadnej wartości (nawet void) Należy dodać że każda klasa ma swój konstruktor. Nawet jeżeli nie zadeklarujemy go jawnie zrobi to za nas kompilator (stworzy wtedy konstruktor bezparametrowy i pusty). Mamy na przykład klasę Miesiac. Chcielibyśmy, aby każdy obiekt tej klasy tuż po utworzeniu wygenerował tablicę z nazwami dni tygodnia w zależności od miesiąca i roku. A może dało by się to zrobić w trakcie tworzenia klasy? Przyjrzyj się poniższej klasie, oraz funkcji konstruktora: class Miesiac public: int dni[31]; int liczbadni; string nazwa; Miesiac();//deklaracja konstruktora ; Miesiac::Miesiac()//definicja konstruktora

C++/Wersja do druku 28 // instrukcje tworzące Konstruktor może też przyjmować argumenty. Jak? To zależy od sposobu w jaki tworzymy obiekt: jako obiekt MojaKlasa obiekt(argumenty); jako wskaźnik do obiektu: MojaKlasa* wsk = new MojaKlasa(argumenty); Teraz powyższa klasa miesiąca może być stworzona z uwzględnieniem numeru miesiąca i roku: class Miesiac public: int dni[31]; int liczbadni; string nazwa; Miesiac(int numer,int rok); ; Miesiac::Miesiac(int numer,int rok) /* instrukcje tworzące */ Aby utworzyć nowy obiekt tej klasy trzeba będzie napisać: Miesiac styczen2000(1,2000); lub jako wskaźnik do obiektu: Miesiac* styczen2000 = new Miesiac(1,2000); otrzymawszy w ten sposób kalendarz na styczeń. Najczęstszą funkcją konstruktora jest inicjalizacja obiektu oraz alokacja pamięci dla dodatkowych zmiennych (w tym celu lepiej jest użyć instrukcji inicjujących, które poznasz już za chwilę). Instrukcje inicjujące Instrukcje inicjujące to instrukcje konstruktora spełniające specyficzne zadanie. Mianowicie mogą one zostać wywołane przez kompilator zaraz po utworzeniu klasy. Służą do inicjowania pól klasy, w tym stałych i referencji. Jeśli nie zaimplementujemy instrukcji inicjujących, niczego nie będą one robiły. Jeżeli chcemy zaimplementować instrukcje inicjujące, musimy po liście argumentów konstruktora, użyć dwukropka, podać nazwę pola, które chcemy zainicjować i jego wartość ujętą w nawiasy okrągłe. Rok() : miesiace(new Miesiac[12]), liczbadni(7)

C++/Wersja do druku 29 /* zamiast średników stosuje się przecinki przy ostatniej instrukcji przecinka nie stosuje się */ Działa to podobnie jak użycie inicjowania w konstruktorze, jednak w przypadku instrukcji inicjujących pola będą zainicjowane w trakcie tworzenia klasy, a nie po utworzeniu jej obiektu. Konstruktor kopiujący Konstruktor kopiujący to konstruktor spełniający specyficzne zadanie. Mianowicie może on zostać wywoływany przez kompilator niejawnie jeżeli zachodzi potrzeba stworzenia drugiej instancji obiektu (np. podczas przekazywania obiektu do funkcji przez wartość). Jeżeli nie zaimplementujemy konstruktora kopiującego, kompilator zrobi to automatycznie. Konstruktor taki będzie po prostu tworzył drugą instancję wszystkich pól obiektu. Możemy go jawnie wywołać np. tak: Miesiac miesiac(12,2005); Miesiac kopia(miesiac); //tu zostanie wywołany konstruktor kopiujący /* obiekt kopia będzie miał taką samą zawartość jak obiekt miesiąc */ Jeżeli chcemy sami zaimplementować konstruktor kopiujący musimy zadeklarować go jako konstruktor o jednym parametrze będącym referencją na obiekt tej samej klasy. class Miesiac public: int numer; int rok; Miesiac(const Miesiac &miesiac) numer=miesiac.numer; rok=miesiac.rok; ;

C++/Wersja do druku 30 Porada Jeżeli dokonujemy w instrukcjach inicjujących alokacji pamięci, np: class Rok protected: Miesiac *miesiace; public: Rok() : miesiace(new Miesiac[12]) virtual ~Rok() delete[] miesiace; ; to nie możemy się zdać na konstruktor kopiujący tworzony niejawnie. Jeżeli tak zrobimy, to w obiekcie stworzonym przez konstruktor kopiujący pole miesiace będzie wskazywać na ten sam fragment pamięci, co w obiekcie wzorcowym. Jeżeli nie jest to zamierzony efekt (a zwykle nie jest) musimy sami zaimplementować konstruktor kopiujący, np. tak: class Rok protected: Miesiac *miesiace; public: Rok() : miesiace(new Miesiac[12]) Rok(const Rok &rok) //musimy sami zaalokować pamięć na pole ''miesiace'' miesiace=new Miesiac[12]; //oraz przypisać temu polu odpowiednie wartości for (int i=0; i<12; ++i) miesiace[i]=miesiac(rok.miesiace[i]); virtual ~Rok() delete[] miesiace; ; Destruktor Destruktor jest natomiast funkcją, którą wykonuje się w celu zwolnienia pamięci przydzielonej dodatkowym obiektom lub innych zasobów. Zasady "przemiany" zwykłej funkcji do destruktora, są podobne do tych tyczących się konstruktora. Jedyna zmiana tyczy się nazwy funkcji: Musi się ona zaczynać od znaku tyldy - ~. class MojaKlasa MojaKlasa();//to oczywiście jest konstruktor ~MojaKlasa();//a to - destruktor ; Najczęstszą funkcją destruktora jest zwolnienie pamięci (zwykle poprzez zniszczenie wszystkich pól używanych przez ten obiekt).