Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00428 008116 11002818 na godz. na dobę w sumie
Język C++. Pierwsze starcie - książka
Język C++. Pierwsze starcie - książka
Autor: Liczba stron: 288
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-1481-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj tajniki programowania w C++

C++ to jeden z najpopularniejszych języków programowania. Stosowany jest zarówno przez profesjonalistów, jak i hobbystów. Wszyscy jego użytkownicy doceniają elastyczność, ogromne możliwości i szybkość działania napisanych w nim programów. Ogromną zaletą C++ jest to, że nie wymusza na programistach stosowania określonego stylu programowania. Z racji swoich możliwości jest to język bardzo złożony, a efektywne programowanie w nim wymaga poznania wielu technik i pojęć oraz umiejętności wykorzystania tej wiedzy w praktyce.

Książka 'C++. Pierwsze starcie' to podręcznik, dzięki któremu opanujesz zasady programowania w tym języku i zdobędziesz solidne podstawy do dalszego rozwijania swoich umiejętności. Znajdziesz w niej opis aktualnego standardu C++ oraz omówienia narzędzi programistycznych i bibliotek. Poznasz elementy języka, zasady programowania obiektowego i tworzenia złożonych aplikacji. Przeczytasz o szablonach, bibliotece STL i obsłudze błędów. Dowiesz się, jak stosować biblioteki przy tworzeniu aplikacji dla systemów Windows i Linux.

Zrób pierwszy krok na drodze do profesjonalnego tworzenia oprogramowania.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

JŒzyk C++. Pierwsze starcie Autor: Zbigniew Koza ISBN: 978-83-246-1481-3 Format: B5, stron: 288 Poznaj tajniki programowania w C++ (cid:149) Jak skonstruowany jest program w jŒzyku C++? (cid:149) Na czym polega programowanie obiektowe? (cid:149) Jak korzysta(cid:230) z bibliotek? C++ to jeden z najpopularniejszych jŒzyk(cid:243)w programowania. Stosowany jest zar(cid:243)wno przez profesjonalist(cid:243)w, jak i hobbyst(cid:243)w. Wszyscy jego u¿ytkownicy doceniaj„ elastyczno(cid:156)(cid:230), ogromne mo¿liwo(cid:156)ci i szybko(cid:156)(cid:230) dzia‡ania napisanych w nim program(cid:243)w. Ogromn„ zalet„ C++ jest to, ¿e nie wymusza na programistach stosowania okre(cid:156)lonego stylu programowania. Z racji swoich mo¿liwo(cid:156)ci jest to jŒzyk bardzo z‡o¿ony, a efektywne programowanie w nim wymaga poznania wielu technik i pojŒ(cid:230) oraz umiejŒtno(cid:156)ci wykorzystania tej wiedzy w praktyce. Ksi„¿ka (cid:132)C++. Pierwsze starcie(cid:148) to podrŒcznik, dziŒki kt(cid:243)remu opanujesz zasady programowania w tym jŒzyku i zdobŒdziesz solidne podstawy do dalszego rozwijania swoich umiejŒtno(cid:156)ci. Znajdziesz w niej opis aktualnego standardu C++ oraz om(cid:243)wienia narzŒdzi programistycznych i bibliotek. Poznasz elementy jŒzyka, zasady programowania obiektowego i tworzenia z‡o¿onych aplikacji. Przeczytasz o szablonach, bibliotece STL i obs‡udze b‡Œd(cid:243)w. Dowiesz siŒ, jak stosowa(cid:230) biblioteki przy tworzeniu aplikacji dla system(cid:243)w Windows i Linux. (cid:149) Struktura programu w C++ (cid:149) Elementy jŒzyka (cid:149) Korzystanie z funkcji (cid:149) Programowanie obiektowe (cid:149) Dynamiczne struktury danych (cid:149) Stosowanie bibliotek (cid:149) Szablony (cid:149) Biblioteka STL (cid:149) Obs‡uga b‡Œd(cid:243)w Zr(cid:243)b pierwszy krok na drodze do profesjonalnego tworzenia oprogramowania Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści Wstęp 1. Pierwszy program w C++ 1.1. Dla kogo jest ta książka? . . . . . . . . . . . . . . . . . . . . . . . . . 1.2. Rys historyczny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3. Zanim napiszesz swój pierwszy program . . . . . . . . . . . . . . . . 1.4. Pierwszy program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5. Obiekt std::cout i literały . . . . . . . . . . . . . . . . . . . . . . . 1.6. Definiowanie obiektów . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7. Identyfikatory, słowa kluczowe i dyrektywy . . . . . . . . . . . . . . . 1.8. Zapis programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.9. Cztery działania matematyczne i typ double . . . . . . . . . . . . . 1.10. Jeszcze więcej matematyki . . . . . . . . . . . . . . . . . . . . . . . . 1.11. Upraszczanie zapisu obiektów i funkcji biblioteki standardowej 1.12. Źródła informacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.13. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.14. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.15. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2. Wyrażenia i instrukcje Instrukcje sterujące . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1. Pętle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2. Typy wbudowane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3. 2.4. Wyrażenia arytmetyczne, promocje i konwersje standardowe . . . . Tworzenie obiektów stałych . . . . . . . . . . . . . . . . . . . . . . . 2.5. 2.6. Popularne typy standardowe . . . . . . . . . . . . . . . . . . . . . . . 2.7. Obiekty lokalne i globalne. Zasięg. Przesłanianie . . . . . . . . . . . 2.8. Operatory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.9. Wyrażenia i instrukcje . . . . . . . . . . . . . . . . . . . . . . . . . . 2.10. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.11. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.12. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3. Funkcje 3.1. Referencje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2. Funkcje swobodne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 13 13 13 16 18 21 22 24 24 25 26 28 28 29 30 30 31 31 33 36 41 43 44 50 51 57 58 58 58 61 61 62 6 Spis treści . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Po co są funkcje? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3. Funkcje składowe – wprowadzenie . . . . . . . . . . . . . . . . . . . 3.4. Argumenty funkcji 3.5. Funkcje zwracające referencję . . . . . . . . . . . . . . . . . . . . . . 3.6. 3.7. Operatory jako funkcje swobodne . . . . . . . . . . . . . . . . . . . . Stos funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.8. 3.9. Funkcje otwarte (inline) 3.10. Funkcje jako argumenty innych funkcji 3.11. Rekurencja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.12. Argumenty domyślne . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.13. Lokalne obiekty statyczne . . . . . . . . . . . . . . . . . . . . . . . . 3.14. Funkcja main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.15. Polimorfizm nazw funkcji 3.16. Deklaracja a definicja funkcji . . . . . . . . . . . . . . . . . . . . . . . 3.17. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.18. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.19. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4. Tablice i wskaźniki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1. Wskaźniki Tablice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2. 4.3. Pamięć wolna (sterta) . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6. 64 66 66 69 70 73 75 77 77 78 79 81 82 82 83 83 83 85 85 89 96 98 98 99 5. Klasy i obiekty 101 5.1. Struktury . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 5.2. Co to są klasy? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 5.3. Definiowanie klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 5.4. Funkcje składowe (metody) . . . . . . . . . . . . . . . . . . . . . . . . 109 5.5. Udostępnianie składowych . . . . . . . . . . . . . . . . . . . . . . . . 115 Interfejs i implementacja . . . . . . . . . . . . . . . . . . . . . . . . . 117 5.6. 5.7. Kontrakty, niezmienniki i asercje . . . . . . . . . . . . . . . . . . . . . 120 5.8. Hermetyzacja danych . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 5.9. Różnice między klasami i strukturami . . . . . . . . . . . . . . . . . . 122 5.10. Dygresja: składowe statyczne . . . . . . . . . . . . . . . . . . . . . . 123 5.11. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 5.12. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 6. Dynamiczne struktury danych 127 Stos na bazie tablicy dynamicznej . . . . . . . . . . . . . . . . . . . . 127 6.1. 6.2. Stos na bazie listy pojedynczo wiązanej . . . . . . . . . . . . . . . . 134 6.3. Dygresja: przestrzenie nazw i zagnieżdżanie definicji klas . . . . . . 137 6.4. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 6.5. 6.6. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 Spis treści 7 7. Dziedziczenie i polimorfizm 141 7.1. Dziedziczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Polimorfizm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 7.2. 7.3. Jak to się robi w Qt? . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 7.4. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 7.5. 7.6. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 8. Strumienie 163 Strumienie buforowane i niebuforowane . . . . . . . . . . . . . . . . 163 8.1. Klawiatura, konsola, plik, strumień napisowy . . . . . . . . . . . . . . 164 8.2. 8.3. Stan strumienia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 8.4. Manipulatory i formatowanie strumienia . . . . . . . . . . . . . . . . 167 8.5. Strumienie wyjścia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Strumienie wejścia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 8.6. Przykład . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 8.7. 8.8. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 8.9. 9. Biblioteki Podział programu na pliki 175 9.1. . . . . . . . . . . . . . . . . . . . . . . . . 175 9.2. Używanie gotowych bibliotek . . . . . . . . . . . . . . . . . . . . . . . 184 9.3. Kompilacja i instalacja programów lub bibliotek z plików źródłowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 9.4. 9.5. 10. Preprocesor i szablony 191 10.1. Preprocesor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 10.2. Szablony . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 10.3. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 10.4. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 11. Wprowadzenie do STL 207 11.1. Co to jest STL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 11.2. Pojemniki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 11.3. Iteratory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 11.4. Algorytmy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 11.5. Wektory (std::vector) . . . . . . . . . . . . . . . . . . . . . . . . . 218 11.6. Liczby zespolone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 11.7. Napisy (std::string) . . . . . . . . . . . . . . . . . . . . . . . . . . 223 11.8. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 11.9. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 11.10. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 12. Pojemniki i algorytmy 227 12.1. Przegląd pojemników STL . . . . . . . . . . . . . . . . . . . . . . . . 227 8 Spis treści 12.2. Przegląd algorytmów swobodnych . . . . . . . . . . . . . . . . . . . . 239 12.3. Kontrola poprawności użycia STL . . . . . . . . . . . . . . . . . . . . 246 12.4. Składniki dodatkowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 12.5. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 12.6. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 12.7. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 13. Obsługa błędów 251 13.1. Rodzaje błędów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 13.2. Analiza błędów składniowych: koncepty . . . . . . . . . . . . . . . . 252 13.3. Wykrywanie błędów logicznych: debuger . . . . . . . . . . . . . . . . 254 13.4. Obsługa błędów czasu wykonania: wyjątki . . . . . . . . . . . . . . 257 13.5. Q A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 13.6. Pytania przeglądowe . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 13.7. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 14. Co dalej? 271 14.1. Problemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 A. Dodatki 273 A.1. Wybrane opcje kompilatora g++ . . . . . . . . . . . . . . . . . . . . . 273 A.2. Dodatkowe elementy języka . . . . . . . . . . . . . . . . . . . . . . . 275 A.3. Zgodność języka C++ z językiem C . . . . . . . . . . . . . . . . . . . 276 A.4. Przyszłość języka C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 277 Źródła informacji w internecie . . . . . . . . . . . . . . . . . . . . . . 278 A.5. Rozdział 4 Tablice i wskaźniki Wskaźniki. Tablice. Tablice znaków a literały napisowe. Tablice a wskaźniki. Operatory new i delete. Pamięć wolna. Poznane w rozdziale 2. typy arytmetyczne (np. int, double, bool, char) nie wyczer- pują zestawu typów wbudowanych języka C++. Do omówienia pozostały m.in. tablice i wskaźniki, czyli te typy danych, które są charakterystyczne dla języka C, a których użyteczność w C++ jest mocno ograniczona. Niemniej jednak jest to bardzo ważny rozdział, gdyż: (i) bez zrozumienia zasad posługiwania się wskaźnikami i tablicami nie można korzystać z żadnej biblioteki C ani zrozumieć sposobu funkcjonowania wielu bibliotek C++; (ii) w pewnych sytuacjach wskaźniki i tablice są niezastąpione także w C++; (iii) wskaźnik jest naturalnym przykładem iteratora. 4.1. Wskaźniki 4.1.1. Definiowanie wskaźników Wskaźnik to obiekt przechowujący adres innego obiektu. Oto prosty przykład użycia wskaźnika: 3 int main() Wydruk 4.1. Przykład użycia wskaźnika { 5 10 } int x = 7; std:: cout ”Zmienna x znajduje sie pod adresem ” x ” ”; int∗ wsk = x; std:: cout ”Pod adresem ” wsk ” znajduje sie liczba ” ∗wsk ” ”; ∗wsk = 10; std:: cout ”Teraz x = ” x ” ”; // −− zmienna ’wsk’ przechowuje adres x EA= N =@KA IEA F@ =@HAIA N BB 2@ =@HAIA N BB =@KA IEA E? = 6AH= N   86 Rozdział 4. Tablice i wskaźniki Do odczytywania adresu obiektu w pamięci operacyjnej służy operator . W tym kontekście został on użyty w wierszu 6 do wyświetlenia na ekranie adresu zmiennej x. Fakt, że operator pobrania adresu zapisywany jest za pomocą tego samego symbolu co operator koniunkcji bitowej i symbol referencji, sprawia początkującym pewne proble- my. Z formalnego punktu widzenia zasadnicza różnica pomiędzy operatorem pobrania adresu a operatorem koniunkcji bitowej polega na tym, że pierwszy z nich jest ope- ratorem jednoargumentowym, a drugi – dwuargumentowym. Z kolei wybór symbolu na oznaczenie referencji odzwierciedla fakt, że przekazywanie argumentów funkcji przez referencję oznacza tak naprawdę przekazywanie adresów argumentów faktycznych. Skoro potrafimy pobrać adres operatorem , dobrze byłoby mieć też możliwość za- pisania go w specjalnej zmiennej. Taką zmienną – zwaną wskaźnikiem – należy oczywi- ście wpierw zdefiniować. W tym celu między nazwą klasy obiektu, którego adres nasza zmienna ma przechowywać, a jej nazwą wstawiamy gwiazdkę – i to wszystko! Przykład zastosowania tej procedury zna jduje się w wierszu 7, w którym zdefiniowano zmienną o nazwie wskaznik. int∗ wsk = x; // −− zmienna ’wsk’ przechowuje adres x W definicji tej na lewo od gwiazdki zna jduje się identyfikator typu (tu: int), dlatego zmienna wskaznik może przechowywać wyłącznie adresy liczb typu int. Typem zmiennej wskaznik jest int*. W wierszu 7 skorzystano też z okazji, by zadośćuczynić regule 1.5 (ze s. 28) i definicję zmiennej adresowej uzupełnić informacją o jej wartości początkowej – w tym przypadku jest nią adres zmiennej x. Skoro mamy już zdefiniowaną zmienną wskaźnikową, pora jej użyć. Możemy z nią zrobić dwie rzeczy. Po pierwsze, możemy uzyskać dostęp do obiektu, którego adres jest w niej zapisany. W tym celu należy poprzedzić jej nazwę gwiazdką, która w tym kontekście zwie się operatorem wyłuskania (gwiazdka „wyłuskuje” wartość obiektu wskazywanego przez wskaźnik). Operator * ma więc tę samą właściwość, co operator : występuje jako operator jednoargumentowy (i zwie się operatorem wyłuskania) lub dwuargumentowy (jako operator mnożenia). Zastosowanie operatora wyłuskania ilustrują wiersze 9 i 10. Pierwszy z nich dowodzi, że za pośrednictwem operatora * możemy odczytywać wartość obiektu wskazywanego przez wskaźnik. Wiersz 10 pokazuje natomiast, że za pośrednic- twem tego operatora można także modyfikować zmienną wskazywaną przez wskaźnik. Drugą czynnością, którą można zrobić ze zmienną wskaźnikową, to zmienienie jej wartości. Ilustruje to następujący przykład: int x = 0, y = 1; // definiujemy dwie różne zmienne całkowite int∗ p = x; ... p = y; // p wskazuje na x // używamy p jako wskaźnika na x // odtąd p wskazuje na y Jak widać, dopóki nie używamy operatora wyłuskania, wskaźniki zachowują się jak zwycza jne zmienne. Należy tylko pamiętać o prostej zasadzie: Reguła 4.1. Jeżeli X i Y oznaczają różne typy, to (z wyjątkiem nielicznych sytuacji opi- sanych w dalszej części podręcznika) wartości wskaźnika typu X* nie można przypisywać zmiennej wskaźnikowej typu Y*. Różnica między referencjami i wskaźnikami jest w sumie niewielka – referencje są na stałe przypisane obiektom, do których się odnoszą, przy czym poprawność tego przy- 4.1. Wskaźniki 87 pisania gwarantowana jest przez kompilator; natomiast wskaźniki mogą zmieniać swo ją wartość, czyli wskazywać na co i rusz inne obiekty, a nawet na obszar pamięci, w którym nie ma żadnych obiektów. Różnica niby niewielka, ale zasadnicza. Dzięki ich „stałości” i udogodnieniom składniowym (brak „gwiazdek”) stosowanie referencji jest bezpieczne, natomiast stosowanie wskaźników wymaga wyobraźni i lat doświadczenia. Reguła 4.2. Jeżeli naprawdę nie musisz, nie używaj wskaźników. 4.1.2. Wskaźniki typu void*, czyli wycieczka w stronę C Ponieważ w języku C nie ma referencji, wskaźniki są w nim wręcz wszechobecne – stano- wią bowiem jedyną metodę przekazywania do funkcji obiektów tak, aby funkcja mogła je modyfikować. Jak wiemy, w C++ zamiast wskaźników używa się w tym celu referencji. Jednak miliony wierszy kodu napisanego w C korzysta ją wyłącznie ze wskaźników, mu- simy więc poznać pewną popularną sztuczkę, którą wprowadzono do C w celu ominięcia reguły 4.1. Otóż wprowadzono specjalny typ wskaźników, void*, które charakteryzują się tym, że można im przypisać wartość wskaźnika dowolnego typu: int x = 0 int∗ p = x; void∗ q = p; // p wskazuje na x // zapisujemy w q wartość p, czyli adres x Ta karkołomna konstrukcja służy w C do przekazywania do funkcji argumentów do- wolnego typu. W C++ ten sam cel, lecz w bardziej bezpieczny sposób, realizują szablony (por. s. 191). Reguła 4.3. Naucz się korzystać ze wskaźników typu void* używanych w cudzym kodzie, ale nigdy, przenigdy nie definiuj ich we własnych programach. 4.1.3. Wskaźnik zerowy W języku C++ przyjęto zasadę, że żaden obiekt nie może mieć adresu o wartości 0. Z drugiej strony każdemu wskaźnikowi można przypisać tę wartość. Oznacza to, że ze- ro jest wartością specjalną, która sygnalizuje jakąś sytuację wyjątkową. Na jczęściej 0 przypisuje się wskaźnikowi, aby zasygnalizować, że w danym momencie nie wskazuje on żadnego obiektu. W języku C zamiast wartości 0 stosuje się stałą symboliczną NULL. 4.1.4. Czym grozi nieumiejętne użycie wskaźników? Wskaźniki to niezwykle niebezpieczne narzędzie, gdyż w źle napisanym programie łatwo mogą wymknąć się spod kontroli i wskazywać zupełnie coś innego, niż wyda je się au- torowi programu. Oto kilka na jczęściej spotykanych rodza jów błędów związanych z nie- umiejętnym użyciem wskaźników: • Wskaźnik wskazuje na inną zmienną, niż wyda je się to programiście. • Wskaźnik wskazuje zmienną innego typu, niż wyda je się to programiście. • Programista usiłuje zapisać dane poprzez wskaźnik zerowy. • Wskaźnik wskazuje na przypadkowe miejsce w pamięci operacyjnej. • Programista nie jest świadomy, że posługuje się wskaźnikiem. 88 Rozdział 4. Tablice i wskaźniki • Wskaźnik wciąż wskazuje na miejsce w pamięci, które jakiś czas temu przestało na- leżeć do programu. • Programista zmienia wartość wskaźnika, który był jedynym do jściem do fragmentu pamięci operacyjnej przydzielonej programowi. Wszystkie opisane tu kłopoty są naprawdę poważne: albo powodują pad programu, albo wyciek pamięci, albo wejście programu w niekontrolowaną turbulencję. Powtórzmy więc raz jeszcze: Reguła 4.4. Jeżeli naprawdę nie musisz, nie używaj wskaźników. 4.1.5. Wskaźniki stałe i wskaźniki na stałe Jeśli z jakichś względów nie można uniknąć użycia wskaźników, powinno się przyna jmniej spróbować ograniczyć liczbę potencjalnych niespodzianek, które mogą nas spotkać z ich strony. Na jłatwiejszy sposób osiągnięcia tego celu to zredukowanie liczby operacji, ja- kie można wykonać na wskaźnikach lub poprzez wskaźniki. Podstawowa metoda polega na użyciu słowa kluczowego const. Za jego pomocą można definiować wskaźniki stałe, wskaźniki na stałe i stałe wskaźniki na stałe, co ilustruje następujący przykład: int x = 0; int ∗ const cp = x; const int ∗ pc = x; const int ∗ const cpc = x; // cpc jest stałym wskaźnikiem na stałą // cp jest stałym wskaźnikiem na x // pc jest wskaźnikiem na stałą Wskaźniki stałe to wskaźniki, które zawsze ma ją tę samą wartość (czyli zawsze wskazują ten sam obiekt). Ponadto wskaźniki stałe muszą być zainicjowane adresem od- powiedniego obiektu (lub zerem). Powyższe dwie właściwości eliminują większość możli- wości błędnego użycia stałego wskaźnika. Pod względem funkcjonalnym stałe wskaźniki są niemal równoważne referencjom. Wskaźniki na stałą to wskaźniki umożliwia jące wyłącznie odczyt stanu wskazy- wanego przez siebie obiektu. Stałe wskaźniki na stałą to połączenie obu powyższych rodza jów wskaźników. W sensie funkcjonalnym są niemal równoważne stałym referencjom. Na jłatwiejszy sposób radzenia sobie ze skomplikowanymi deklaracjami wskaźników polega na odczytywaniu ich od tyłu, co ilustruje rysunek 4.1. const int * const p p jest obiekt klasy int stałym wskaźnikiem na którego nie może zm ienić Rysunek 4.1. Definicje wskaźników najłatwiej odczytuje się od tyłu 4.2. Tablice 89 4.1.6. Wskaźniki na wskaźniki Oczywiście obiekt wskazywany przez wskaźnik sam może być wskaźnikiem. Oto przykład: int x = 0; int∗ px = x; int∗∗ pp = px; W języku C wskaźniki na wskaźniki stosowane są m.in. jako argumenty funkcji (gdy funkcja ma zmienić wartość wskaźnika przekazanego w jej argumencie) lub do tworzenia tablic dwuwymiarowych (szczególnie takich, w których poszczególne wiersze mogą mieć różne długości). 4.2. Tablice Tablice są niskopoziomową wersją poznanych w rozdziale 2. wektorów, odziedziczoną 1 jeszcze z języka C. Tablica to po prostu ciąg obiektów określonej klasy posiada jący swo ją nazwę i przechowywany w spó jnym fragmencie pamięci operacyjnej. Liczba elementów tego ciągu zwana jest rozmiarem tablicy i musi być znana już podczas kompilacji pro- gramu. Przykład zastosowania tablicy prezentuje wydruk 4.2. Zawiera on dwie funkcje: fibo1 i fibo3, które stanowią rozwiązanie zadania 5 (s. 84). Wydruk 4.2. Przykład użycia tablicy 4 int fibo1(int n) 5 { if (n = 2) return 1; return fibo1(n−1) + fibo1(n−2); } 10 const int fibo max = 50; int fibo tab[fibo max] = {0}; int fibo3(int n) 15 { if (n = 2 or n = ::fibo max) return 1; if (::fibo tab[n] == 0) 20 ::fibo tab[n] = fibo3(n−1) + fibo3(n−2); return ::fibo tab[n]; } Pierwsza z tych funkcji, fibo1, stanowi rozwiązanie czysto rekurencyjne. Wyróżnia się elegancją, jednak nie grzeszy efektywnością: wyznaczenie 46 kolejnych liczb Fibo- nacciego za jmuje jej na moim komputerze 2 minuty i 38 sekund. Druga z tych funkcji, fibo3, również korzysta z rekurencji, jednak wyznaczenie 46 kolejnych liczb Fibonacciego za jmuje jej zaledwie jedną milionową sekundy. Jak to jest możliwe? 1 Tj. dostosowaną bardziej do możliwości komputera niż potrzeb człowieka. 90 Rozdział 4. Tablice i wskaźniki Otóż funkcja fibo3 stara się nie powtarzać raz przeprowadzonych obliczeń. Dlatego po pierwszym obliczeniu swo jej wartości dla danego argumentu zapisuje odpowiada jącą mu wartość w specjalnej tablicy. Przy każdym wywołaniu funkcja na jpierw sprawdza w tablicy, czy nie zapisała już w niej poszukiwanej wartości. Jeśli tak, po prostu zwraca ją. Jeżeli nie – wykorzystuje rekurencję do znalezienia swo jej wartości dla bieżącego argumentu, zapisuje ją w tablicy i dopiero wtedy zwraca jako swo ją wartość. Prześledźmy, jak powyższy scenariusz został zrealizowany na wydruku 4.2. W wierszu 10 zdefiniowano stałą symboliczną fibo_max, która określa rozmiar tablicy przechowu- jącej wartości funkcji (por. reguła 2.7 na s. 44). Samą tablicę tworzy się w wierszu 12, stosując instrukcję o ogólnej postaci TYP ELEMENTU NAZWA TABLICY [ROZMIAR TABLICY]; Dodatkowo wraz ze zdefiniowaniem tablicy wszystkim jej elementom nadano wartość początkową 0 (ten element języka zostanie szczegółowo opisany w punkcie 4.2.2). Funkcja fibo3 na jpierw sprawdza, czy jej argument mieści się w rozmiarze tablicy. Jeśli nie – zwraca 1. Jeśli argument jest poprawny, funkcja sprawdza, czy odpowiada jąca mu liczba Fibonacciego nie została wcześniej zapisana w globalnej tablicy fibo_tab. Wykorzystano tu fakt, że żadna liczba Fibonacciego nie ma wartości 0. Jak widać, dostęp do n-tego elementu tablicy zapewnia operator []. Oznacza to, że nie ma żadnej różnicy w używaniu tablic i wektorów. Reguła 4.5. Pierwszy element tablicy n-elementowej ma indeks 0, a ostatni ma indeks n-1. Użycie indeksu spoza zakresu 0. . . n-1 oznacza poważny błąd, który może doprowa- dzić nawet do padu programu. Nie ma chyba programisty, który choć raz na własnej skórze nie odczuł doniosłości powyższej reguły. 4.2.1. Tablice wielowymiarowe Elementami tablic mogą być inne tablice. Oto prosty przykład: int tab[3][2]; tab[1][1] = 100; // dostęp do elementu 1,1 // definicja tablicy dwuwymiarowej 3 na 2 W pierwszym wierszu tego kodu definiuje się tablicę trzech obiektów, z których każdy jest tablicą dwóch liczb typu int. W sumie zdefiniowano więc dwuwymiarową tablicę 3 × 2 liczb typu int, co ilustruje rysunek 4.2. Z kolei w drugim wierszu elementowi tab11 przypisano wartość 100. tab[0][0] tab[0][1] tab[1][0] tab[1][1] tab[2][0] tab[2][1] tab[0] tab[1] tab[2] RAM tab Rysunek 4.2. Sposób umieszczenia w pamięci operacyjnej tablicy int tab[3][2] 4.2. Tablice 91 4.2.2. Inicjalizacja tablic W wierszu 12 programu z wydruku 4.2 zastosowano specjalną konstrukcję służącą do nadawania wartości początkowej tablicy: int fibo tab[ fibo max] = {0}; Jak widzimy, inicjalizacja tablicy wygląda podobnie do inicjalizacji zwykłej zmiennej, tj. rozpoczyna się znakiem =. Główna różnica polega na tym, że tablicę można (a często nawet trzeba) inicjalizować kilkoma wartościami. Wartości te poda je się po znaku = jako ujętą w klamry listę, w której poszczególne pozycje oddzielone są od siebie przecinkiem. Podczas tworzenia kodu inicjalizacji tablicy kompilator stosuje następującą regułę: Reguła 4.6. Jeżeli lista inicjalizacyjna tablicy zawiera mniej elementów niż rozmiar tablicy, to kompilator uzupełni ją zerami. To właśnie ta reguła (a nie wpisanie 0 w klamrach) gwarantuje, że wszystkie elementy tablicy fibo_tab będą początkowo miały wartość 0. W kontekście inicjalizacji warto jeszcze zapamiętać następującą regułę: Reguła 4.7. Wszystkie zmienne, obiekty i tablice globalne domyślnie inicjalizowane są zerami. Wynika stąd, że tak naprawdę inicjalizacja tablic globalnych zerami jest zbędna. Mimo to w programie z wydruku 4.2 zastosowałem jawną inicjalizację, ponieważ zwiększa to czytelność kodu – od razu informuje bowiem ewentualnego czytelnika, że inicjalizacja tablicy fibo_tab zerami jest istotnym składnikiem kodu. Reguła 4.8. Unikaj stosowania niejawnych inicjatorów. Oto kilka przykładów zastosowania inicjatorów tablicy: int tab1[3] = {0}; int tab2[3] = {1}; int tab22a[2][2] = {0, 1, 2, 3}; int tab22b[2][2] = {{0, 1}, {2, 3}}; double tab4[ ] = {1.0, 10.0, 100.0}; // 0, 0, 0 // 1, 0, 0 // tab22a[1][1] == 3 // to samo co powyżej Na szczególną uwagę zasługują puste nawiasy kwadratowe w ostatniej z powyższych instrukcji. Jeżeli wraz z definicją tablicy poda jemy jej listę inicjalizacyjną, w defini- cji tablicy możemy pominąć jej rozmiar. W tym przypadku kompilator sam „dopisze” wymaganą wartość na podstawie liczby elementów listy inicjalizacyjnej. 4.2.3. Zastosowanie operatora sizeof do tablic Jak już wiemy, operator sizeof zwraca liczbę ba jtów za jmowanych przez dany obiekt w pamięci operacyjnej. Jeżeli jako argumentu tego operatora użyjemy nazwy tablicy, zwróci on liczbę ba jtów za jmowanych przez tablicę. Właściwość ta ma zastosowanie do wyznaczania rozmiaru tablicy w przypadku, gdy jej rozmiar zdefiniowano niejawnie poprzez użycie inicjatora tablicy: double tab4[] = {1.0, 10.0, 100.0}; const int rozmiar tablicy = sizeof(tab4)/sizeof(tab4[0]); W powyższym kodzie zmienna rozmiar_tablicy będzie miała poprawną wartość nawet po zmianie liczby elementów tablicy lub ich typu. 92 Rozdział 4. Tablice i wskaźniki 4.2.4. Tablice a wskaźniki W językach C i C++ obowiązuje następująca reguła: Reguła 4.9. Nazwa tablicy może być traktowana jak wskaźnik na jej pierwszy element. Własność tę demonstruje wydruk 4.3. Wydruk 4.3. Odpowiedniość między nazwą tablicy a wskaźnikiem na jej pierwszy element 3 int main() { 5 10 } int tab[4] = {1, 2, 3, 4}; std::cout tab ” ” tab[0] ” ”; int∗ p = tab; std::cout p ” ” ∗p ” ” p[1] ” ”; std::cout sizeof(p) ” ” sizeof(tab) ” ”; N BB$ N BB$ N BB$  $ W wierszu 5 zdefiniowano tablicę tab i nadano jej kolejnym elementom wartości po- czątkowe 1, 2, 3 i 4. W wierszu 6 „wysłano” nazwę tablicy na standardowe wyjście, w wyniku czego na ekranie po jawił się napis 0x22ff60. Notacja szesnastkowa (por. s. 40) oznacza, że na ekranie faktycznie wyświetlono wartość adresu (a nie np. kolejnych ele- mentów tablicy). W tej samej instrukcji operatorem pobrano adres pierwszego elementu tablicy i również wyświetlono go na ekranie. Wynik potwierdza regułę 4.9. W wierszu 7 adres pierwszego elementu tablicy przypisano wskaźnikowi p. Wiersz 8 dowodzi, że wskaźnika tego można używać tak samo jak nazwy tablicy (np. stosować do niego operator indeksowania). Spostrzeżenie 4.1. Wskaźniki różnią się od nazw tablic sposobem definiowania, nie różnią się zaś sposobem używania. Wskaźników można używać jak nazw tablic, a nazw tablic jak wskaźniki. Wiersz 9 dowodzi, że kompilator odróżnia jednak wskaźniki od nazw tablic. Nazwa tablicy zawsze wskazuje na to samo miejsce, w którym na pewno zna jduje się tablica, dlatego sizeof(tab) zwraca liczbę ba jtów za jmowanych przez tablicę. Wskaźnik może wskazywać na cokolwiek, dlatego sizeof(p) zwraca liczbę ba jtów za jmowanych przez wskaźniów. 4.2.5. Tablice wskaźników i wskaźniki na tablice W języku C++ można definiować zarówno tablice wskaźników, jak i wskaźniki na tablice. Składnia definicji takich obiektów wyda je się na pierwszy rzut oka bardzo skompliko- wana, ale można ją ogarnąć dzięki następującej regule, stanowiącej uogólnienie zasady podanej na s. 88: 4.2. Tablice 93 Reguła 4.10. Odczytywanie definicji wskaźnika rozpoczynamy od nazwy zmiennej, po czym odczytujemy definicję w prawo do napotkania prawego nawiasu okrągłego lub koń- ca definicji; następnie kontynuujemy odczytywanie deklaracji w kierunku przeciwnym, poczynając od nazwy zmiennej, aż do napotkania otwierającego nawiasu okrągłego lub początku definicji. Procedurę tę powtarzamy rekurencyjnie do wyczerpania wszystkich nawiasów. Oto kilka przykładów użycia tej reguły: int const∗ p[5]; int (∗q) [5]; char const ∗(∗ const (∗pp)[])[10]; void (∗f)(double ); Pierwszą z powyższych instrukcji odczytujemy następująco (strzałki informują o kie- runku odczytywania definicji): „p → jest tablicą pięciu ← wskaźników na stałe obiekty typu int”. Drugą odczytujemy tak: „q ← jest wskaźnikiem → na tablicę pięciu ← liczb typu int”. Trzecia deklaracja jest nieco trudniejsza: „pp jest ← wskaźnikiem → na tablicę ← stałych wskaźników → na tablicę dziesięciu ← wskaźników na stałe znaki”. Ostatnią definicję można odczytać następująco: „f jest ← wskaźnikiem → na funkcję przyjmującą jeden argument typu double przez referencję ← i nie zwraca jącą żadnej wartości”. 4.2.6. Tablice jako argumenty funkcji Tablice nie są do funkcji przekazywane ani przez wartość (byłaby to karygodna roz- rzutność), ani przez referencję (bo mechanizmu tego nie ma w C), lecz przez wskaźnik. Przykład przekazania tablicy do funkcji przedstawia wydruk 4.4. Zawiera on m.in. de- finicję funkcji suma, której zadaniem jest obliczenie sumy elementów tablicy. Funkcja ta jest więc odpowiednikiem funkcji oblicza jącej sumę elementów wektora (por. wydruk 3.6 na s. 69). 3 double suma(double tab[], int rozmiar tablicy) Wydruk 4.4. Przekazywanie tablic do funkcji { 5 } 10 double wynik = 0.0; for (int i = 0; i rozmiar tablicy; ++i) wynik += tab[i]; return wynik; int main() { const int rozmiar = 5000; double v[rozmiar]; for (int i = 0; i rozmiar; ++i) v[i ] = static cast double (i) / rozmiar; std:: cout suma(v, rozmiar) ” ”; 15 } 94 Rozdział 4. Tablice i wskaźniki W wierszu 3 rozpoczyna się definicja funkcji suma. Ponieważ tablice są obiektami niskopoziomowymi, nie zawiera ją informacji o swoim rozmiarze. Dlatego funkcja suma musi pobrać dwa argumenty: nazwę tablicy (czyli adres jej pierwszego elementu) i jej rozmiar. W deklaracjach argumentów tablicowych funkcji z zasady nie poda je się ich roz- miaru, lecz używa się pustej pary nawiasów kwadratowych. Faktycznymi argumentami tych funkcji mogą być tablice o dowolnym rozmiarze. Funkcję suma wywołuje się w wierszu 18. Oczywiście jako argumentu funkcji używa się nazwy tablicy (czyli adresu jej pierwszego elementu). Dlatego wiersz 18 równie dobrze mógłby być zapisany następująco: std:: cout suma( v[0], rozmiar) ” ”; Analogicznie prototyp funkcji suma mógłby wyglądać następująco: double suma(double ∗tab, int rozmiar tablicy) Byłoby to jednak dość mylące – użycie „zwykłego” wskaźnika sugerowałoby, że funkcja przyjmuje przez wskaźnik tylko jeden obiekt, a nie całą tablicę. Jak widać, przy przekazywaniu tablic do funkcji w pełni wykorzystuje się odpowied- niość między nawami tablic a wskaźnikami na ich pierwszy element. 4.2.7. Teksty literalne i tablice znaków Mimo że niejednokrotnie używałem już w tym podręczniku literałów tekstowych (czyli ciągów znaków ujętych w cudzysłów, np. koniec programu ), to aż dotąd unikałem odpowiedzi na pytanie, jaki jest ich typ. Okazuje się, że są to stałe tablice znaków za- kończone specjalnym znakiem ’’ o wartości 0. Np. typem literału tekstowego koniec jest const char[7], a składa się on z elementów ’k’, ’o’, ’n’, ’i’, ’e’, ’c’, ’’. Dlatego też wartością wyrażenia sizeof( koniec ) jest 7. Znak ’’, zwany też bajtem zerowym, dopisywany jest automatycznie na końcu tablicy przez kompilator. Literały tekstowe mogą służyć do uproszczonej inicjalizacji tablic znaków. Np. za- miast char tab[] = {’A’, ’l ’ , ’ a’, ’ ’ , ’ m’, ’ a’, ’ ’ , ’ k’, ’ o’, ’ t’ , ’ a’, ’ ’}; można napisać po prostu char tab[] = ”Ala ma kota”; Podręcznikowy przykład zastosowania tablic znaków w stylu języka C przedstawia wydruk 4.5. Zna jdująca się w nim funkcja kopiuj służy do kopiowania tekstu przeka- zywanego w drugim argumencie do obszaru wskazywanego przez pierwszy argument. Kopiowanie kontynuowane jest tak długo, aż zostanie skopiowany ba jt zerowy. JAIJ )= = J= = @KCI?  Mimo swo jej pozornej elegancji (związanej z wyjątkowo zwięzłym zapisem) funk- cja ta obnaża dwa poważne problemy związane ze stosowaniem tekstów w stylu C. Po pierwsze, funkcja kopiuj nie ma po jęcia, czy i ile miejsca zarezerwowano pod adresem dokad. Funkcja nie ma też żadnych informacji na temat rzeczywistej długości kopiowanej tablicy znaków. Obie te właściwości są potencjalnym źródłem bardzo poważnych błę- dów. Zaprawdę korzystanie z tekstów w stylu C wymaga od programisty dużej wprawy i samodyscypliny. 4.2. Tablice 95 Wydruk 4.5. Przykład funkcji operującej na tablicach tekstowych w stylu C 4 void kopiuj(char∗ dokad, const char∗ skad) 5 { while(∗dokad++ = ∗skad++) continue; } 10 int main() { char bufor[200]; kopiuj (bufor, ”Ala ma kota”); std:: cout ”tekst ’” bufor ”’ ma dlugosc ” strlen(bufor) ” ”; 15 } Reguła 4.11. W miarę możliwości należy posługiwać się napisami w stylu języka C++, czyli obiektami typu std::string; z języka C warto zapożyczyć wyłącznie literały tek- stowe. 4.2.8. Porównanie tablic i wektorów Porównanie tablic (w stylu języka C) z wektorami (w stylu języka C++) zdecydowanie wypada na korzyść tych drugich. Jedyną zaletą tablic jest to, że w funkcjach traktowane są jak zwykłe zmienne lokalne, w związku z czym pamięć dla nich rezerwowana jest już w czasie kompilacji programu. Innymi słowy, samo utworzenie tablicy nie kosztuje programu dosłownie nic (poza pamięcią operacyjną). Niestety, wektory biblioteki C++ tworzone są dopiero podczas wykonywania programu, dlatego samo ich utworzenie jest stosunkowo kosztowne. Wynika stąd, że wewnątrz intensywnie wykorzystywanej pętli for lepiej jest definiować tablice niż wektory. Można jednak ominąć ten problem, definiując wektor przed pętlą. A oto główne zalety wektorów w stosunku do tablic: • Rozmiar wektorów nie musi być znany podczas kompilacji. • Wektory przechowują informację o swoim rozmiarze. • Wektory mogą zmieniać swó j rozmiar podczas wykonywania się programu. • Dostęp do dowolnego elementu wektora jest równie szybki, jak dostęp do elementu tablicy. • Dane przechowywane w wektorach nie obciąża ją obszaru stosu funkcji – dlatego nawet lokalne wektory mogą mieć gigantyczne rozmiary. • Bez wprowadzania dodatkowego kodu do programu można spowodować, by podczas wykonania programu była sprawdzana poprawność użycia każdego indeksu wektora (por. spostrzeżenie 11.8 na s. 220). Reguła 4.12. Tablic w stylu języka C używaj tylko wtedy, gdy naprawdę musisz. Niemal zawsze lepszym pomysłem jest użycie wektorów C++. 96 Rozdział 4. Tablice i wskaźniki 4.3. Pamięć wolna (sterta) Wszystkie obiekty, z którymi mieliśmy dotąd do czynienia, charakteryzowały się tym, że programista wybierał dla nich nazwę, ale miejsce w pamięci operacyjnej rezerwował dla nich kompilator w jednym z dwóch bloków pamięci – albo w obszarze zmiennych globalnych, albo na stosie funkcji. W C++ istnieje też metoda tworzenia obiektów „na żądanie”, tj. tylko w określonych sytuacjach, których wystąpienia nie można przewi- dzieć podczas kompilacji programu. Obiekty tworzone na żądanie zwane są obiektami dynamicznymi, blok pamięci, w którym przechowywane są takie obiekty, zwany jest pa- mięcią wolną lub stertą, a proces tworzenia obiektów dynamicznych na stercie zwany jest dynamiczną alokacją pamięci. Spostrzeżenie 4.2. Słowo „dynamiczny” oznacza „taki, którego pełna charakterystyka ustalana jest dopiero podczas wykonywania się programu” 2. Podstawowe sposoby tworzenia obiektów dynamicznych ilustruje wydruk 4.6: Wydruk 4.6. Tworzenie obiektów dynamicznych 5 10 int∗ p = new int; ∗p = 7; double∗ q = new double (3.14); std::cout ”∗p = ” ∗p ”, ∗q = ” ∗q ” ”; delete p; delete q; F   G  ! W wierszu 5 za pomocą operatora new tworzona jest na stercie nowa zmienna typu int. Zmienna ta nie ma swojej nazwy, a dostęp do niej możliwy jest wyłącznie poprzez wskaźniki. W szczególności operator new zwraca jako swo ją wartość właśnie adres zare- zerwowany w pamięci operacyjnej dla nowo utworzonego obiektu. Na wydruku 4.6 adres ten jest natychmiast zapisywany w zmiennej wskaźnikowej p. Spostrzeżenie 4.3. Obliczenie wyrażenia new NAZWA KLASY powoduje zarezerwowanie na stercie pamięci dla obiektu klasy NAZWA_KLASY, a wartością tego wyrażenia jest adres tego obszaru pamięci. W wierszu 6 nowo utworzonej zmiennej dynamicznej przypisywana jest wartość 7. Oczywiście czyni się to za pośrednictwem zmiennej wskaźnikowej i operatora wyłuskania. Ustalenie wartości początkowej obiektu powinno być – w miarę możliwości – wy- konywane już w momencie jego tworzenia. Niestety, metoda użyta w wierszach 5 i 6 nie spełnia tego warunku. Na szczęście C++ umożliwia jednoczesne utworzenie obiektu dynamicznego i nadanie mu wartości początkowej – w tym celu wartość początkową umieszcza się w nawiasach okrągłych za nazwą typu. Metodę tę ilustruje wiersz 7. 2 Antonimem słowa „dynamiczny” jest (w tym kontekście) słowo „statyczny”. Np. „dynamiczna kontrola typów” to kontrola poprawności użycia argumentów funkcji wykonywana podczas wykonywania progra- mu; „statyczna kontrola typów” wykonywana jest przez kompilator w fazie translacji kodu źródłowego na kod maszynowy, czyli przed uruchomieniem programu. 4.3. Pamięć wolna (sterta) 97 W przypadku używania obiektów dynamicznych programista zobowiązany jest nie tylko do ich jawnego tworzenia, ale i do ich jawnego zniszczenia. Do zwalniania pamięci służy specjalny operator delete. Przykład jego użycia demonstrują wiersze 8 i 9. Po zwolnieniu pamięci operatorem delete nie wolno już się do niej odwoływać. Reguła 4.13. Obiekty utworzone dynamicznie na stercie powinny być z niej jawnie usunięte operatorem delete. Tworzenie dynamicznych obiektów reprezentujących po jedyncze obiekty typu int czy double nie jest specjalnie interesujące. Jednym z podstawowych zastosowań operatora new jest tworzenie dynamicznych tablic. Przykład przedstawia wydruk 4.7. Wydruk 4.7. Tworzenie i usuwanie tablic dynamicznych 5 std::cout ”podaj rozmiar tablicy: ”; int n; std::cin n; int ∗ const p = new int [n]; for (int i = 0; i n; ++i) p[i] = i; 10 // ... delete [] p; W wierszach 5–7 program wczytuje z klawiatury dowolną liczbę n klasy int. Następnie w wierszu 8 tworzy na stercie tablicę n liczb typu int, a jej adres zapisuje w zmiennej wskaźnikowej p. Rozmiar tablicy podawany jest w nawiasach kwadratowych po nazwie klasy i nie musi być znany podczas kompilacji. Spostrzeżenie 4.4. Obliczenie wyrażenia new NAZWA KLASY [ROZMIAR] powoduje zarezerwowanie na stercie bloku pamięci dla tablicy zawierającej ROZMIAR obiek- tów klasy NAZWA_KLAY, a wartością wyrażenia jest adres tego obszaru pamięci. Zgodnie ze spostrzeżeniem 4.1 (s. 92) wskaźnik przechowujący adres początku tablicy można traktować jak jej nazwę – wykorzystano to w wierszu 10. Wiersz 12 ukazuje sposób usunięcia niepotrzebnej już tablicy ze sterty. Zwolniona w ten sposób pamięć może być następnie wykorzystywana w innych fragmentach pro- gramu lub przez inne programy. Posługiwanie się pamięcią wolną to skomplikowany temat godzien osobnego opraco- wania. Oto kilka dodatkowych wskazówek ułatwia jących to zadanie. • Operator new i operator new [] to dwa różne operatory. Podobnie delete i delete [] to dwa różne operatory. Pamięć pobraną operatorem new należy zwalniać wyłącznie operatorem delete, a pamięć pobraną operatorem new [] należy zwalniać operatorem delete []. • Argumentem operatorów delete może być wyłącznie adres zwrócony wcześniej przez odpowiedni operator new. • Argumentem operatorów delete nie może być adres obszaru pamięci zwolnionego już operatorem delete. 98 Rozdział 4. Tablice i wskaźniki • Argumentem operatorów delete może być adres zerowy (nie powoduje to żadnych konsekwencji). • Może się zdarzyć, że operator new nie będzie mógł znaleźć miejsca na stercie. W tym przypadku w starszych implementacjach C++ operator ten zwracał adres zerowy; w nowych implementacjach operator new zgłasza wyjątek std::bad_alloc (wyjątki zostaną omówione w rozdziale 13.). • Podczas alokacji tablic obiektów nie ma możliwości przekazania im inicjatorów (tj. ta- blice dynamiczne wymaga ją osobnej inicjalizacji). Na jważniejsza jest jednak następująca reguła: Reguła 4.14. Bezpośrednie korzystanie z pamięci wolnej jest trudniejsze, niż się to wy- daje, i rzadko kiedy naprawdę potrzebne. Zanim użyje się operatorów new i delete, warto się zastanowić, czy tego samego efektu nie osiągnie się za pomocą klas biblioteki stan- dardowej, np. std::vector T czy std::list T . 4.4. Q A Czy to prawda, że tablice bezpośrednio tworzone operatorem new działają szybciej niż standardowe wektory std::vector? Jeżeli kompilator pracuje w trybie optymalizacji prędkości, to nie ma żadnej różnicy. Tak naprawdę klasa std::vector to bardzo efektywna, wysokopoziomowa „obudowa” tablic tworzonych operatorem new. Czy to prawda, że wskaźniki są szybsze od operatora indeksowania? Nieprawda. Zamiana kodu źródłowego wykorzystującego tablice na kod źródłowy wyko- rzystujący wskaźniki z reguły prowadzi do jego zaciemnienia, natomiast uzyskany kod maszynowy jest praktycznie taki sam. Jaka jest różnica między int const* p i const int * p? Żadna. Pierwsza z tych form lepiej odpowiada regule 4.10, jednak bardziej popularna jest druga z nich. Zupełnie nie rozumiem programu z wydruku 4.5! To normalne – przecież ten program napisano nie w C++, tylko w C! Nieco poważniej: proszę spróbować rozwiązać problem 1. 4.5. Pytania przeglądowe 1. Co to są wskaźniki? 2. Do czego służy operator wyłuskania? 3. W jaki sposób można określić adres, pod którym zna jduje się dany obiekt? 4. Jaka jest różnica między wskaźnikami na stałą a wskaźnikami stałymi? 5. Jaki jest związek między nazwami tablic w stylu języka C a wskaźnikami? 6. Dlaczego należy unikać stosowania wskaźników? 7. W jaki sposób definiuje się wartości początkowe elementów tablic? 8. Jaki jest związek tekstów literalnych (np. Ala ma kota ) z tablicami? 9. Co to jest ba jt zerowy? 10. Jakie są zalety wektorów C++ w stosunku do tablic w stylu języka C? 4.6. Problemy 99 11. Jakie są zalety tablic w stylu C w stosunku do wektorów C++? 12. Co to jest pamięć wolna? 13. Co w języku C++ oznacza przymiotnik „dynamiczny”? 14. Do czego służy i co zwraca operator new? 15. Do czego służy operator delete? 16. Jaka jest różnica między delete i delete []? 17. Jaki jest efekt wykonania instrukcji delete 0;? 4.6. Problemy 1. Spó jrz na wydruk 4.5 i odpowiedz na następujące pytania: • Który z operatorów użytych w wyrażeniu warunkowym pętli while ma na jwyższy, a który na jniższy priorytet. • Jak działa i jaką wartość zwraca przyrostkowy operator ++? • Do czego służy jednoargumentowy operator *? • Jaką wartość zwraca operator przypisania? • Jak interpretowane jest wyrażenie warunkowe w pętli while, jeżeli zamiast wyra- żenia logicznego (o wartości true lub false) po jawia się w nim wyrażenie aryt- metyczne? 2. Zadeklaruj: • Wskaźnik na tablicę stu liczb typu double. • Dwuwymiarową tablicę 5× 5 wskaźników na char. • Tablicę (o nieokreślonej długości) wskaźników na char. • Standardowy wektor wskaźników void*. • Czteroelementową tablicę wektorów o elementach typu double. • Wskaźnik na funkcję zwraca jącą jako wartość liczbę typu double i przyjmującą dwa argumenty: tablicę (w stylu C) liczb typu double oraz liczbę typu int. • Dowolną funkcję przyjmującą przez referencję wskaźnik na int. 3. Zna jdź takie N, dla którego wykonanie pętli for (unsigned n = 1; n = N; ++n) { int∗ p = new int[n]; delete [] p; } trwa około jednej sekundy. Na tej podstawie porówna j koszt (=czas) wykonania po je- dynczej pary instrukcji new / delete z kosztem po jedynczego dodawania. (Wskazówka: koszt dodawania można oszacować podobnie w innej pętli for). 4. Program int main() { double tab[10]; double x; std:: cout x ” ” tab[−1] ” ”; } 100 Rozdział 4. Tablice i wskaźniki produkuje w moim komputerze następujący wynik: N BB N BB Skomentuj i wyjaśnij to zjawisko. Czy występuje ono także w Twoim komputerze? Jakie konsekwencje może mieć niepoprawne indeksowanie tablic? 5. Wyjaśnij, w jaki sposób w poniższym programie wykorzystano indolencję programi- sty do włamania się do systemu? 3 int main() { 5 10 15 } // tu będzie przechowywane hasło char haslo[8]; strcpy(haslo, ”Ta.jnE!”); // kopiuje drugi argument w miejsce pierwszego for ( ; ; ) { std:: cout ”podaj haslo: ”; char tmp[8]; std:: cin tmp; if (strcmp(tmp, haslo) == 0) // czy teksty są takie same? // zmienna tymczasowa na wczytanie hasła break; std:: cout ”przykro mi, haslo jest niepoprawne! ”; } std:: cout ”witaj w systemie! ”; F@= D=I  ! #$  ! #$ FHOH E D=I AIJ EAFFH=MA F@= D=I  ! #$ MEJ= M IOIJAEA 6. Działanie programów z zadań 4 i 5 zależy od użytego kompilatora i platformy, na której są uruchamiane. Wyjaśnij, dlaczego. Jeżeli w Twoim komputerze da ją one inne wyniki niż w moim, zmodyfikuj je tak, by osiągnąć ten sam efekt.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Język C++. Pierwsze starcie
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: