Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00131 008230 10493973 na godz. na dobę w sumie
Język C++. Efektywne programowanie obiektowe - książka
Język C++. Efektywne programowanie obiektowe - książka
Autor: Liczba stron: 800
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-812-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj metody programowania
stosowane przez profesjonalistów

Programowanie obiektowe jest nierozerwalnie związane z językiem C++. Koncepcje i metody programowania obiektowego, niezbędne do swobodnego posługiwania się tą techniką, pomimo pozornej prostoty są stosunkowo trudne do opanowania. Projektowanie aplikacji w języku C++ wymaga jednak nie tylko znajomości podstawowych zasad programowania obiektowego, ale również wielu innych technik programistycznych. Należy prawidłowo zaplanować strukturę aplikacji, poznać zasady pisania poprawnego kodu i nauczyć się korzystać z notacji UML do modelowania zależności pomiędzy elementami aplikacji.

'C++. Efektywne programowanie obiektowe' to podręcznik przeznaczony zarówno dla początkujących, jak i zaawansowanych programistów C++. Przedstawia metody programowania obiektowego stosowane przez profesjonalistów. Opisuje techniki obiektowe w kontekście rzeczywistych problemów, przed jakimi stają twórcy oprogramowania podczas codziennej pracy.

Dzięki zawartym w tej książce wiadomościom wykonasz nawet najtrudniejsze zadania programistyczne, wykorzystując techniki obiektowe.

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Jêzyk C++. Efektywne programowanie obiektowe Autor: Kayshav Dattatri T³umaczenie: Micha³ Grzegorczyk, Jaromir Senczyk, Przemys³aw Steæ, Przemys³aw Szeremiota, Tomasz Walczak ISBN: 83-7361-812-0 Tytu³ orygina³u: C++: Effective Object-Oriented Software Construction Format: B5, stron: 800 Programowanie obiektowe jest nierozerwalnie zwi¹zane z jêzykiem C++. Koncepcje i metody programowania obiektowego, niezbêdne do swobodnego pos³ugiwania siê t¹ technik¹, pomimo pozornej prostoty s¹ stosunkowo trudne do opanowania. Projektowanie aplikacji w jêzyku C++ wymaga jednak nie tylko znajomoġci podstawowych zasad programowania obiektowego, ale równie¿ wielu innych technik programistycznych. Nale¿y prawid³owo zaplanowaæ strukturê aplikacji, poznaæ zasady pisania poprawnego kodu i nauczyæ siê korzystaæ z notacji UML do modelowania zale¿noġci pomiêdzy elementami aplikacji. „C++. Efektywne programowanie obiektowe” to podrêcznik przeznaczony zarówno dla pocz¹tkuj¹cych, jak i zaawansowanych programistów C++. Przedstawia metody programowania obiektowego stosowane przez profesjonalistów. Opisuje techniki obiektowe w kontekġcie rzeczywistych problemów, przed jakimi staj¹ twórcy oprogramowania podczas codziennej pracy. • Podstawowe pojêcia i koncepcje programowania obiektowego • Abstrakcja danych • Notacja UML • Zarz¹dzanie pamiêci¹ w programowaniu obiektowym • Dziedziczenie • Zasady programowania generycznego • Obs³uga wyj¹tków • Zaawansowane aplikacje obiektowe Dziêki zawartym w tej ksi¹¿ce wiadomoġciom wykonasz nawet najtrudniejsze zadania programistyczne, wykorzystuj¹c techniki obiektowe. Spis treści Rekomendacje ...................................................c............................. 13 Przedmowa ...................................................c.................................. 15 Wstęp ...................................................c......................................... 17 Część I Pojęcia, techniki i aplikacje ...........................................21 Rozdział 1. Czym jest programowanie obiektowe? ............................................. 23 Pochodzenie ................................................... ................................................... .............23 Przykład programowania proceduralnego ................................................... ............. 24 Reprezentacja konta bankowego ................................................... ........................... 25 Bezpieczeństwo konta bankowego ................................................... ........................ 26 Rozwiązywanie problemów w programowaniu obiektowym ................................... 27 Wprowadzenie do modelu obiektowego ................................................... ....................... 28 Terminologia ................................................... ................................................... ............30 Poznajemy komunikaty, metody i zmienne egzemplarza ............................................... 30 Z czego składa się obiekt? ................................................... ..................................... 31 Tworzenie obiektów ................................................... .............................................. 32 Co można uznać za klasę? ................................................... ........................................... 33 Co nie jest klasą? ................................................... ................................................... ......34 Cel klasy ................................................... ................................................... ................... 35 Więcej o obiektach ................................................... ................................................... ... 36 Stan obiektu ................................................... ................................................... ....... 36 Dlaczego stan obiektu jest ważny? ................................................... ........................ 37 Kto kontroluje stan obiektu? ................................................... ................................. 38 Zachowanie obiektu ................................................... .............................................. 39 Etapy w konstruowaniu oprogramowania obiektowego ................................................. 40 Analiza obiektowa ................................................... ................................................. 40 Projektowanie obiektowe ................................................... ...................................... 41 Programowanie obiektowe ................................................... .......................................... 43 Kluczowe elementy modelu obiektowego ................................................... ................... 43 Paradygmaty i języki programowania obiektowego ................................................... .... 45 Jakie wymagania musi spełniać język obiektowy? ................................................... ...... 46 Zalety modelu obiektowego ................................................... ........................................ 47 Podsumowanie ................................................... ................................................... ......... 48 6 Język C++. Efektywne programowanie obiektowe Rozdział 2. Czym jest abstrakcja danych? ...................................................c...... 49 Analiza projektu odtwarzacza ................................................... ..................................... 51 Oddzielanie interfejsu od implementacji ................................................... ..................... 52 Znaczenie interfejsu ................................................... .............................................. 52 Dlaczego interfejs obiektu jest tak ważny? ................................................... .................. 53 Jaki interfejs jest wystarczający? .................................................. ............................ 53 Znaczenie implementacji ................................................... ............................................. 54 Ochrona implementacji ................................................... ............................................... 54 Jakie są korzyści ukrywania danych? ................................................... .......................... 56 Relacje między interfejsem, implementacją i hermetyzacją danych ............................... 57 Środki ostrożności przy hermetyzacji danych ................................................... ............. 58 Co i kiedy ukrywać? ................................................... ................................................... . 58 Abstrakcyjne typy danych ................................................... ........................................... 59 Implementacja abstrakcyjnego typu danych — stosu ................................................... .. 60 Abstrakcja danych w języku C++ ................................................... ................................ 62 Regiony dostępu klasy ................................................... ................................................. 63 Niektóre pojęcia związane z klasami ................................................... ........................... 69 Kto jest implementatorem klasy? ................................................... ................................ 70 Implementowanie funkcji składowych ................................................... ........................ 70 Identyfikacja obiektu docelowego w funkcjach składowych .......................................... 71 Przykładowy program ................................................... ................................................. 73 Uwaga skoncentrowana jest na obiekcie ................................................... ........................ 74 Drugi rzut oka na interfejs ................................................... ........................................... 75 Czym są bezpieczne klasy wielowątkowe? ................................................... ................. 76 Zapewnianie niezawodności abstrakcji — niezmienniki i asercje klasy ......................... 78 Niezmienniki klasy ................................................... ................................................ 79 Warunki wstępne i warunki końcowe ................................................... ................... 79 Używanie asercji do implementowania niezmienników i warunków ....................... 80 Efektywne korzystanie z asercji ................................................... ............................ 81 Sposoby reprezentacji projektów obiektowych ................................................... ........... 82 Notacja Boocha ................................................... ................................................... ........ 83 Relacje między klasami ................................................... ............................................... 83 Asocjacja ................................................... ................................................... ............ 84 Agregacja (ma-coś) ................................................... ............................................... 84 Relacja korzystania ................................................... ............................................... 86 Relacja dziedziczenia (jest-czymś) ................................................... ........................ 87 Kategorie klas ................................................... ................................................... .... 88 UML ................................................... ................................................... ......................... 88 Relacje między klasami ................................................... ............................................... 90 Asocjacja ................................................... ................................................... .................. 90 Asocjacja jako agregacja ................................................... ....................................... 92 Asocjacja typu OR ................................................... ................................................ 93 Kompozycja ................................................... ................................................... ............. 93 Relacja uogólniania (jest-czymś) ................................................... ................................. 94 Znaczenie relacji ma-coś ................................................... ............................................. 95 Podsumowanie ................................................... ................................................... ......... 97 Rozdział 3. Abstrakcja danych w języku C++ ...................................................c.. 99 Podstawowe informacje o klasie ................................................... ................................. 99 Elementy klasy ................................................... ................................................... ....... 100 Regiony dostępu ................................................... .................................................. 100 Konstruktor kopiujący ................................................... ............................................... 103 Dostęp do danych składowych obiektu — model języka C++ ............................... 106 Operacja przypisania ................................................... ................................................. 111 Więcej o wskaźniku this i dekorowaniu nazw ................................................... ........... 116 Metoda stała (const) ................................................... .................................................. 118 Spis treści 7 Jak kompilator implementuje metody stałe? .................................................. ............... 120 Różnice między klasą a strukturą w języku C++ ................................................... ....... 120 Co może zawierać klasa? ................................................... ........................................... 121 W czasie projektowania najważniejszy jest interfejs klasy ........................................... 122 Nazwy klas, nazwy metod, typy argumentów i dokumentacja ..................................... 123 Sposoby przekazywania argumentów z perspektywy klienta ....................................... 124 Semantyka własności ................................................... ................................................ 128 Wybór odpowiedniego sposobu przekazywania argumentu ......................................... 130 Wartości zwracane przez funkcję ................................................... .............................. 131 Zwracanie referencji ................................................... .................................................. 133 Jak napisać bezpieczną pod względem pamięci klasę? ................................................. 134 Optymalizacja kodu ................................................... ............................................ 134 Obowiązki klienta w pracy z klasami i funkcjami ................................................... ..... 134 Podsumowanie ................................................... ................................................... ....... 136 Rozdział 4. Inicjalizacja i zwalnianie pamięci w programowaniu obiektowym ...... 137 Co to jest inicjalizacja? ................................................... .............................................. 137 Inicjalizacja za pomocą konstruktora ................................................... .................. 139 Reguły pracy z obiektami zagnieżdżonymi ................................................... ......... 146 Zagadnienia związane z przywracaniem pamięci ................................................... ...... 146 Śmieci ................................................... ................................................... .............. 146 Wiszące referencje ................................................... .............................................. 147 Jak zapobiegać powstawaniu śmieci i wiszących referencji? ................................. 148 Przywracanie pamięci a projektowanie języka ................................................... .... 149 Kiedy powstają śmieci w języku C++? ................................................... ............... 151 Kiedy obiekt zajmuje zasoby? ................................................... ............................. 152 Przywracanie pamięci w języku C++ ................................................... ........................ 152 Tożsamość obiektów ................................................... ................................................. 154 Semantyka kopiowania obiektów ................................................... .............................. 157 Semantyka prostej operacji kopiowania ................................................... .............. 158 Semantyka przypisywania obiektów ................................................... ......................... 163 Przypisanie jako operacja na l-wartości ................................................... .............. 166 Semantyka porównywania obiektów ................................................... ......................... 166 Równość obiektów a ekwiwalencja ................................................... ..................... 168 Dlaczego potrzebna jest kontrola kopiowania? ................................................... ......... 170 Przykład semafora ................................................... ............................................... 171 Przykład — serwer licencji ................................................... ................................. 173 Przykład — klasa String ................................................... ...................................... 174 Analiza ................................................... ................................................... ................... 180 Kopiowanie przy zapisie ................................................... ........................................... 182 Kiedy używać zliczania referencji? ................................................... ..................... 188 Podsumowanie kopiowania przy zapisywaniu ................................................... .... 188 Klasy i typy ................................................... ................................................... ............189 Podsumowanie ................................................... ................................................... ....... 190 Rozdział 5. Dziedziczenie ...................................................c............................. 191 Podstawy dziedziczenia ................................................... ............................................. 191 Znaczenie relacji dziedziczenia ................................................... ................................. 205 Skutki relacji dziedziczenia ................................................... ....................................... 205 Bezpośrednie i pośrednie klasy bazowe ................................................... .............. 206 Zasada podstawiania polimorficznego ................................................... ...................... 207 Inicjalizacja obiektów klasy bazowej ................................................... .................. 210 Rozszerzanie hierarchii klas za pomocą dziedziczenia ................................................. 213 Podstawowe zalety dziedziczenia ................................................... .............................. 215 Wiązanie dynamiczne, funkcje wirtualne i polimorfizm .............................................. 216 Co oznacza wiązanie dynamiczne? ................................................... ..................... 219 Obsługa wiązania dynamicznego — funkcje wirtualne ......................................... 220 8 Język C++. Efektywne programowanie obiektowe Wpływ dziedziczenia na hermetyzację danych ................................................... ......... 222 Co oznacza polimorfizm? ................................................... .......................................... 224 Efektywne stosowanie funkcji wirtualnych ................................................... ............... 225 Przesłanianie ................................................... ................................................... .... 225 Kiedy potrzeba wirtualnego destruktora? ................................................... .................. 228 Konstruktory i funkcje wirtualne ................................................... ............................... 231 Uogólnianie-uszczegóławianie ................................................... .................................. 233 Klasy abstrakcyjne ................................................... ................................................... . 233 Zastosowania klas abstrakcyjnych ................................................... ............................. 237 Zaawansowany przykład klasy abstrakcyjnej — gra w szachy .............................. 241 Waga dziedziczenia ................................................... ................................................... 249 Efektywne wielokrotne używanie kodu ................................................... ..................... 250 Klient abstrakcyjnej klasy bazowej ................................................... ........................... 253 Podsumowanie zalet dziedziczenia .................................................. ............................. 254 Zagrożenia związane z dziedziczeniem i wiązaniem dynamicznym ............................ 256 Jak implementowane są funkcje wirtualne w języku C++? .................................... 257 Koszty funkcji wirtualnych ................................................... ................................. 258 Dynamiczne wiązanie i sprawdzanie typu .................................................. ............ 259 Zbędne używanie dziedziczenia i wiązania dynamicznego .......................................... 259 Wypożyczanie zbiorów bibliotecznych ................................................... ............... 259 Różne sposoby używania funkcji wirtualnych ................................................... .......... 270 Podsumowanie ................................................... ................................................... ....... 272 Rozdział 6. Dziedziczenie wielokrotne ...................................................c.......... 273 Prosta definicja dziedziczenia wielokrotnego ................................................... ............ 273 Abstrakcja uniwersytetu ................................................... ............................................ 274 Powtórne wykorzystanie kodu z ulepszeniami ................................................... .... 278 Znaczenie wielokrotnego dziedziczenia ................................................... .................... 280 Przykład dziedziczenia wielokrotnego ................................................... ...................... 281 Rozwiązywanie konfliktów nazw w języku C++ ................................................... 282 Problem z wieloznacznością klas bazowych ................................................... ....... 285 Podstawowe zalety dziedziczenia wielokrotnego ................................................... ...... 287 Rozwiązania alternatywne dla dziedziczenia wielokrotnego ........................................ 287 Pierwsze rozwiązanie alternatywne ................................................... ..................... 287 Drugie rozwiązanie alternatywne ................................................... ........................ 290 Problem powtórnego dziedziczenia ................................................... ........................... 291 Rozwiązanie problemu powtórnego dziedziczenia ................................................... .... 295 Dzielenie obiektów za pomocą wirtualnych klas bazowych .................................. 295 Zalety wirtualnych klas bazowych ................................................... ...................... 297 Nowe problemy wynikające z użycia wirtualnych klas bazowych ......................... 297 Porównanie dziedziczenia wielokrotnego w językach Eiffel i C++ ....................... 302 Ogólne problemy z dziedziczeniem ................................................... ........................... 304 Dodawanie statycznych możliwości za pomocą klas mieszanych ................................ 306 Definicja klasy mieszanej ................................................... .................................... 306 Kiedy należy używać klas mieszanych? ................................................... .............. 310 Dynamicznie zmieniająca się sytuacja ................................................... ...................... 311 Elastyczność projektu z klasami pełniącymi różne role ......................................... 316 Jak używać klas pełniących różne role? ................................................... .............. 316 Inne rozwiązanie zarządzania rolami ................................................... .................. 324 Polimorficzne używanie obiektów TUniversityMember ........................................ 326 Wprowadzanie zmian w istniejących klasach ................................................... ..... 326 Klasy mieszane a obiekty pełniące role — możliwości zastosowań ...................... 328 Wyprowadzenie prywatne w języku C++ ................................................... .................. 330 Kiedy używać wyprowadzenia prywatnego? ................................................... ...... 332 Ponowne eksportowanie składowych prywatnej klasy bazowej ............................. 334 Alternatywne rozwiązanie dla wyprowadzenia prywatnego — zawieranie ........... 335 Kiedy potrzebne jest prywatne wyprowadzenie? ................................................... 337 Spis treści 9 Bardzo użyteczny przykład dotyczący klas mieszanych i wyprowadzenia prywatnego .....340 Dziedziczenie a zawieranie ................................................... ....................................... 345 Podsumowanie ................................................... ................................................... ....... 347 Rozdział 7. Selektywny eksport z klas (funkcje zaprzyjaźnione) ........................ 349 Czego nam potrzeba? ................................................... ................................................ 349 Eksport selektywny w języku C++ ................................................... ............................ 350 Konsekwencje związku przyjaźni ................................................... ............................. 353 Zastosowania funkcji niebędących składowymi oraz funkcji zaprzyjaźnionych .......... 357 Przypadek 1. Minimalizowanie silnych interakcji pomiędzy klasami .................... 357 Przypadek 2. Przezwyciężanie problemów składniowych ..................................... 363 Przypadek 3. Funkcje, które wymagają komunikacji z więcej niż jedną klasą ....... 374 Przewaga funkcji niebędących składowymi ................................................... .............. 376 Wybór pomiędzy funkcjami zaprzyjaźnionymi a funkcjami składowymi .................... 379 Podsumowanie ................................................... ................................................... ....... 380 Rozdział 8. Przeciążanie operatorów ...................................................c............ 383 Różnica pomiędzy typami standardowymi a typami definiowanymi przez programistę ....383 Czym jest operator przeciążony? ................................................... ............................... 386 Przeciążać czy nie przeciążać — plusy i minusy przeciążania operatorów .................. 388 Bardziej eleganckie abstrakcyjne typy danych ................................................... .... 388 Zagmatwane przeciążanie operatorów ................................................... ................ 389 Brak zrozumienia zasad pierwszeństwa i łączności ............................................... 389 Operatory przeciążone w języku C++ ................................................... ....................... 392 Inne zastosowanie operatorów ++ oraz -- ................................................... .................. 397 Operator indeksowania — operator [ ] ................................................... ................ 399 Rzecz bardziej wyrafinowana — operator dostępu do składowych, czyli – ............... 405 Operatory jako funkcje składowe lub jako funkcje niebędące składowymi ................. 414 Operatory będące funkcjami składowymi ................................................... ........... 415 Operatory implementowane w postaci funkcji niebędących składowymi .............. 416 Dlaczego potrzebujemy konwersji? ................................................... .................... 420 Funkcje konwersji ................................................... ................................................... .. 421 Interakcje pomiędzy konstruktorami konwertującymi a funkcjami konwersji ....... 424 Eliminacja potrzeby tworzenia obiektów tymczasowych ....................................... 428 Zwracanie wyników z funkcji operatorowych ................................................... ........... 430 Operator przypisania ................................................... ................................................. 435 Podsumowanie ................................................... ................................................... ....... 435 Rozdział 9. Typy generyczne ...................................................c........................ 437 Problem powtarzania kodu ................................................... ........................................ 437 Eleganckie rozwiązanie — programowanie generyczne .............................................. 444 Podstawy typu generycznego (klasy generycznej) ................................................... .... 446 Co się dzieje podczas konkretyzacji nowej klasy szablonowej w języku C++? ..... 448 Typy generyczne a powielanie kodu ................................................... ......................... 453 Kontrakt pomiędzy implementatorem klasy generycznej a jej klientami ..................... 454 Czy można to uznać za „dobry projekt”? ................................................... ............ 459 Operatory a funkcje składowe w implementacji klas generycznych ...................... 462 Rozwiązanie alternatywne — specjalizacja klas generycznych ............................. 464 Specjalizacje szablonów ................................................... ............................................ 464 Specjalizacja funkcji składowej szablonu ................................................... ........... 465 Inne rozwiązanie — wydzielenie operacji porównania obiektów .......................... 467 A jeśli nie można zdefiniować specjalizacji określonej funkcji składowej szablonu? ................................................... ........... 469 Specjalizacja klas szablonowych ................................................... ............................... 470 Koncepcja funkcji generycznych ................................................... ............................... 472 10 Język C++. Efektywne programowanie obiektowe Konkretyzacja klas szablonowych i funkcji składowych w języku C++ ...................... 476 Typy generyczne a kontrola typów .................................................. ............................. 482 Generyczność z ograniczeniami i bez ograniczeń ................................................... ..... 484 Ograniczenia parametrów szablonu w języku C++ ................................................ 488 Konkretne typy jako parametry szablonu w języku C++ ....................................... 488 Wartości domyślne parametrów szablonu ................................................... ........... 490 Nakładanie ograniczeń na parametry szablonu w języku C++ ..................................... 491 Klasy generyczne a eksport selektywny ................................................... .................... 494 Dziedziczenie a klasy generyczne ................................................... ............................. 497 Polimorfizm a klasy generyczne ................................................... ......................... 501 Przydatne zastosowania dziedziczenia wraz z klasami generycznymi ......................... 504 Podejście typu singleton ................................................... ...................................... 504 Ogólna technika kontrolowania tworzenia obiektów ................................................... . 506 Implementacja wskaźników zliczanych ................................................... ..................... 508 Minimalizowanie powielania kodu w przypadku obiektów szablonowych .................. 517 Zapotrzebowanie programu na pamięć .................................................. ................. 519 Sposoby redukcji rozmiaru kodu szablonowego ................................................... . 519 Klasy szablonowe a ochrona kodu źródłowego ................................................... ......... 531 Klasy szablonowe w bibliotekach współdzielonych (dynamicznych) .......................... 531 Klasy szablonowe w bibliotekach współdzielonych — problem wielokrotnych egzemplarzy ................................................... .......... 534 Eliminacja wielokrotnie występujących egzemplarzy w bibliotekach współdzielonych ................................................... ...................... 535 Konsolidacja z istniejącymi bibliotekami współdzielonymi .................................. 537 Klasy kontenerowe ................................................... .............................................. 538 Porównanie klas generycznych i mechanizmu dziedziczenia ....................................... 539 Podsumowanie ................................................... ................................................... ....... 540 Rozdział 10. W oczekiwaniu nieoczekiwanego ...................................................c 543 Po co obsługiwać sytuacje wyjątkowe? ................................................... ..................... 543 Dlaczego kody błędów nie są wystarczające? ................................................... ..... 544 Jakie mamy możliwości? ................................................... ........................................... 545 Model obsługi wyjątków języka C++ ................................................... ........................ 546 Działanie mechanizmu wyjątków w języku C++ ................................................... 547 Wpływ bloku kodu chronionego na program ................................................... ...... 549 Wpływ zgłaszanego wyjątku na program ................................................... ............ 550 Dynamiczny łańcuch wywołań ................................................... ........................... 551 Obsługa wielu wyjątków ................................................... ..................................... 554 Odpowiedzialność klauzuli catch ................................................... ........................ 555 Model wyjątków w języku Eiffel ................................................... .............................. 556 Porównanie modeli wyjątków w językach C++ i Eiffel ............................................... 560 Efektywne stosowanie wyjątków w C++ ................................................... ...................... 563 Tworzenie hierarchii wyjątków ................................................... ................................. 563 Kolejność klauzul przechwytujących ................................................... .................. 566 Odporność funkcji na wyjątki ................................................... ............................. 568 Zagadnienia projektowe dotyczące obsługi wyjątków ................................................. 570 Kiedy zgłaszać wyjątki? ................................................... ...................................... 570 Strategie skutecznego zarządzania błędami w projekcie .............................................. 573 Funkcje nie są zaporami ................................................... ...................................... 574 Projektowanie hierarchii wyjątków ................................................... ..................... 575 Zarządzanie zasobami w środowisku wyjątków ................................................... ........ 578 Automatyzacja zarządzania zasobami ................................................... ................. 579 Uogólnianie rozwiązania zarządzania zasobami ................................................... . 582 Spis treści 11 Wyjątki a konstruktory ................................................... .............................................. 584 Zwracanie zabezpieczonych zasobów z funkcji ................................................... .. 585 Klasa pomocna w zarządzaniu tablicami obiektów ................................................ 588 Koszt automatycznego zarządzania zasobami ................................................... ..... 594 Częściowa skuteczność konstruktora ................................................... ........................ 594 Bezpieczne tworzenie tablic z wykorzystaniem wyjątków ........................................... 595 Podsumowanie ................................................... ................................................... ....... 601 Część II Tworzenie zaawansowanych aplikacji obiektowych .......603 Rozdział 11. Poznawanie abstrakcji danych ...................................................c.... 605 Ukrywanie szczegółów implementacji abstrakcji ................................................... ...... 605 Zalety używania uchwytów ................................................... ................................. 609 Wady używania uchwytów ................................................... ................................. 609 Wskaźniki w roli danych składowych (opóźnianie ewaluacji) ..................................... 613 Kontrolowanie sposobu tworzenia obiektów ................................................... ............. 616 Wymuszanie stosowania operatora new() ................................................... ........... 616 Blokowanie stosowania operatora new() ................................................... ............. 619 Używanie wskaźników i referencji zamiast obiektów zagnieżdżonych ........................ 619 Wady stosowania dużych tablic jako zmiennych automatycznych (lub jako danych składowych) ................................................... ................................ 620 Używanie tablic obiektów oraz tablic wskaźników do obiektów ................................. 621 Obiekty zamiast wskaźników typów prostych (w danych składowych i wartościach zwracanych przez funkcje składowe) .................................................. 624 Zgodność z językiem C ................................................... ............................................. 627 Rozmiar obiektu a efektywność kodu — szukanie implementacji alternatywnych ...... 629 Unikanie obiektów tymczasowych ................................................... ............................ 632 Inicjalizowanie obiektów konstruktorem kopiującym .................................................. 633 Efektywne używanie obiektów proxy (lub obiektów zastępczych) .............................. 634 Obiekty proxy ułatwiające bezpieczne współdzielenie obiektów ........................... 634 Łatwość używania obiektów proxy ................................................... ..................... 637 Obiekty proxy będące zastępcami obiektów zdalnych ........................................... 638 Inteligentne obiekty proxy dostarczające dodatkowej funkcjonalności .................. 638 Klasy proxy do rozwiązywania problemów składniowych i semantycznych ......... 639 Technika ogólnego indeksowego obiektu proxy ................................................... . 642 Używanie prostych abstrakcji do budowy bardziej złożonych ..................................... 644 Abstrakcje dające użytkownikom wybór sposobu stosowania klas .............................. 645 Podsumowanie ................................................... ................................................... ....... 647 Rozdział 12. Efektywne korzystanie z dziedziczenia ........................................... 649 Wykorzystanie dziedziczenia w eleganckich implementacjach menu .......................... 649 Obsługa menu różnych typów ................................................... ............................. 655 Hermetyzacja szczegółów fazy tworzenia obiektu ................................................... .... 656 Koncepcja konstruktorów wirtualnych ................................................... ...................... 658 Funkcje wirtualne i niewirtualne w kontroli protokołu ................................................ 661 Koncepcja podwójnego rozgłaszania wywołań ................................................... ......... 670 Projektowanie i implementacja klas kontenerów .................................................. ........ 677 Projektowanie obsługi różnych kontenerów ................................................... .............. 679 Implementacja klas kontenerów homogenicznych z użyciem programowania generycznego ................................................... ............... 691 Cele projektowe ................................................... .................................................. 692 Zalety kontenerów homogenicznych opartych na szablonach ................................ 697 Wady kontenerów szablonowych ................................................... ........................ 698 Implementacja heterogenicznych kontenerów na podstawie homogenicznych kontenerów wskaźników ................................... 698 12 Język C++. Efektywne programowanie obiektowe Przeglądanie kontenerów .................................................. ............................................ 701 Iteratory pasywne ................................................... ................................................ 702 Iteratory aktywne ................................................... ................................................... .... 705 Iteratory jako obiekty ................................................... .......................................... 708 Zarządzanie kolekcjami i iteratorami z punktu widzenia użytkownika ........................ 715 Metoda 1. Utworzenie iteratora w kontenerze i przekazanie go użytkownikowi ... 715 Metoda 2. Zwracanie kopii kontenera, aby użytkownik swobodnie nim manipulował ................................................... . 716 Biblioteka standardowa języka C++ (STL) ................................................... ............... 718 Kontenery STL ................................................... ................................................... . 719 Iteratory ................................................... ................................................... ............ 720 Algorytmy biblioteki STL ................................................... ................................... 721 Podsumowanie ................................................... ................................................... ....... 723 Kod implementujący kontener TArray ................................................... ...................... 724 Rozdział 13. Wewnętrzny model obiektowy w C++ ............................................ 735 Efektywna implementacja ................................................... ......................................... 735 Reprezentacja obiektów w C++ ................................................... ................................. 735 Obiekty klas pozbawionych funkcji wirtualnych ................................................... 736 Metody ................................................... ................................................... ............. 736 Statyczne dane składowe ................................................... ..................................... 738 Konstruktory ................................................... ................................................... .... 738 Klasy z metodami wirtualnymi ................................................... .................................. 739 Rozmieszczenie wskaźnika tablicy vtbl ................................................... .............. 740 Współużytkowanie tablic funkcji wirtualnych przez biblioteki współdzielone ............ 743 Metody wirtualne a dziedziczenie wielokrotne (bez wirtualnych klas bazowych) ....... 743 Wirtualne klasy bazowe ................................................... ............................................ 749 Odwołania do składowych z wirtualnymi klasami bazowymi ................................ 750 Wirtualne klasy bazowe z metodami wirtualnymi ................................................. 752 Implementacja mechanizmu RTTI (informacja o typie w czasie wykonania) .............. 754 Programowanie obiektowe a programowanie z wykorzystaniem obiektów ................. 756 Referencje, wskaźniki i wartości ................................................... ............................... 756 Przypisania referencji i wskaźników ................................................... ................... 756 Konstruktor kopiujący ................................................... ......................................... 758 Zadania konstruktora ................................................... ........................................... 758 Zadania konstruktora kopiującego ................................................... ............................. 761 Optymalizacja przekazywania i zwracania obiektów przez wartość ............................ 763 Przekazywanie przez wartość ................................................... .............................. 763 Zwracanie przez wartość ................................................... ..................................... 765 Inicjalizacja czasu wykonania ................................................... ................................... 768 Podsumowanie ................................................... ................................................... ....... 768 Dodatki ...................................................j...................................769 Dodatek A Przestrzenie nazw ...................................................c...................... 771 Deklaracja using ................................................... .................................................. 772 Dyrektywa using ................................................... ................................................. 773 Przestrzeń nazw std ................................................... ............................................. 773 Dodatek B Bibliografia i lista lektur zalecanych .............................................. 775 Skorowidz ...................................................c.................................. 779 Rozdział 1. Czym jest programowanie obiektowe? Ostatnio niemal wszyscy pracujący w przemyśle związanym z produkcją oprogramo- wania zachwycają się paradygmatem programowania obiektowego. Nawet menadże- rowie, dyrektorzy i pracownicy marketingu zakochali się w technologii obiektowej. Można odnieść wrażenie, że nie istnieje nic lepszego od podejścia obiektowego. Wy- gląda na to, że programy obiektowe stały się Świętym Graalem, którego wszyscy po- szukują. Niektórzy mogą się zastanawiać, czym jest ten nowy paradygmat i czym różni się od standardów, które obowiązywały przez dziesięciolecia. Programiści mogą poczuć się odstawieni na boczny tor wraz z całym doświadczeniem i umiejętnościa- mi, które w obliczu obiektowego potwora nie są już potrzebne. Jeśli weźmie się to wszystko pod uwagę, warto zapoznać się z odpowiedziami na poniższe pytania:     O co chodzi w tym całym konstruowaniu oprogramowania obiektowego? Jakie są z tego korzyści? W czym różni się ono od tradycyjnego podejścia do konstruowania oprogramowania? Jaki wpływ ma programowanie obiektowe na tradycyjne umiejętności związane z konstruowaniem oprogramowania?  Jak można stać się „obiektowym”? Pochodzenie Programiści konstruowali oprogramowanie od dziesięcioleci i zwykle stosowali bardzo małe programy do wielkich systemów. Używali przy tym rozmaitych języków progra- mowania, takich jak Algol, COBOL, Lisp, C czy Pascal. Bardzo mały program ozna- cza na przykład rozwiązanie problemu wież Hanoi, pasjansa, prostą implementację sortowania quicksort i inne programy, które pisze się w ramach zadania domowego na 24 Część I ♦ Pojęcia, techniki i aplikacje kursie lub po prostu dla nauki. Programy te nie mają żadnej wartości komercyjnej. Po- magają za to w nauce nowego pojęcia lub języka. Dla odmiany termin wielkie systemy odnosi się do systemów oprogramowania, które rozwiązują poważne problemy, takie jak kontrola rezerw czy zarządzanie finansami. Przy ich implementacji współpracują zespoły programistów i projektantów. Następnie producenci puszczają je w obieg. Nauka wyniesiona z projektowania i implementowania małych programów pomaga w rozwią- zywaniu dużych problemów. Na co dzień używa się systemów zaimplementowanych za pomocą wszystkich podanych języków. Na podstawie doświadczeń z tymi językami i systemami zebrana została także szeroka wiedza. Dlaczego więc powinno zmieniać się paradygmat programowania? Czytaj dalej. Odpowiedź stanie się oczywista po prze- czytaniu kolejnych kilku akapitów. Przykład programowania proceduralnego Kiedy programista staje przed koniecznością rozwiązania jakiegoś problemu, który po- daje mu się na przykład w postaci ustnego lub pisemnego opisu, w jaki sposób powi- nien zabrać się za projektowanie i implementowanie rozwiązania przy użyciu języka takiego jak C? Programista rozbija problem na mniejsze, bardziej znaczące fragmenty, zwane modułami. Następnie projektuje struktury do przechowywania danych i imple- mentuje potrzebne funkcje, nazywane także procedurami, które działają na tych danych. Funkcje mogą zmieniać wartość struktur danych, zapisywać je do pliku lub wyświe- tlać. Cała wiedza systemu wbudowana jest w zestaw funkcji. Główny nacisk położony jest na te funkcje, ponieważ bez nich nie można wykonać żadnej pożytecznej operacji. Styl programowania, gdy w centrum zainteresowania są funkcje, nazywa się progra- mowaniem proceduralnym. Nazwa wzięła się stąd, że najważniejszym elementem są tu procedury. Ich waga bierze się z myślenia o problemie w kategoriach jego funkcji. Taki sposób myślenia nazywa się funkcjonalną analizą problemu. Podział na procedury, funkcje i podprogramy nie istnieje w językach C i C++. Jed- nak w językach Pascal, Modula-2 i Eiffel używane jest pojęcie funkcji, które określa podprogram zwracający obliczoną wartość, oraz pojęcie procedury, które określa podprogram pobierający argumenty i wykonujący operacje, ale niezwracający war- tości. W tej książce pojęcia procedura i funkcja używane są zamiennie. Mają one identyczne znaczenie. Języki takie jak Algol, Fortran, Pascal i C nazywane są języ- kami proceduralnymi. Jednak kiedy przyjrzymy się dokładniej implementacjom, możemy zauważyć, że naj- ważniejsze informacje znajdują się w strukturach danych. Tym, co nas najbardziej in- teresuje, są wartości przechowywane w tych strukturach — te, które w programowaniu proceduralnym zostały odstawione na boczny tor. Procedury, które implementujemy, to proste narzędzia do operowania strukturami danych. Bez tych struktur procedury nie miałyby na czym działać. Większość czasu spędzamy na projektowaniu procedur i poświęcamy im całą uwagę mimo tego, że najważniejsze elementy znajdują się gdzie indziej. Ponadto kod w tych procedurach nigdy nie zmienia się w czasie działania pro- gramu. To dane w strukturach danych podlegają takim zmianom. Pod tym względem procedury są dość nieciekawe, ponieważ zachowują się statycznie. Wyobraź sobie na przykład system bankowy, w którym klienci mogą otwierać różne rodzaje kont, takie Rozdział 1. ♦ Czym jest programowanie obiektowe? 25 jak rachunki oszczędnościowe, rachunki bieżące i kredytowe. Klienci mogą lokować pieniądze na koncie, wycofywać wkład i przesyłać pieniądze między rachunkami. Jeśli system implementowany jest w języku C, prawdopodobnie zobaczysz taki ze- staw procedur1: V[RGFGHWPUKIPGFNQPI#EEQWPV0WO V[RGFGHKPVDQQN DQQN/CMG GRQUKV #EEQWPV0WOYJKEJ#EEQWPVHNQCVCOQWPV  HNQCV9KVJ TCY #EEQWPV0WOYJKEJ#EEQWPVHNQCVJQYOWEJ  DQQN6TCPUHGT #EEQWPV0WOHTQO#EEQWPV0WOVQHNQCVJQYOWEJ  #EEQWPV0WO może być dowolną dodatnią liczbą całkowitą. Możemy stworzyć prostą strukturę danych do zarządzania rachunkami: Prosty typ strukturalny do przechowywania informacji o koncie UVTWEV#EEQWPV] EJCT PCOG nazwa właściciela konta  #EEQWPV0WOCEEQWPV+F HNQCVDCNCPEG HNQCVKPVGTGUV;6  wysokość odsetek  EJCTCEEQWPV6[RG Oszczędnościowy, Bieżący, Kredytowy itd.   i wiele innych szczegółów  _ Możemy utworzyć rachunek klienta, tworząc egzemplarz struktury #EEQWPV za pomocą funkcji: #EEQWPV0WO TGCVG0GY#EEQWPV EQPUVEJCTPCOG=?EJCTV[RG1H#EEQWPV  Reprezentacja konta bankowego Funkcja ta zwraca numer rachunku nowego konta. Kiedy popatrzymy na to rozwiąza- nie, staje się jasne, że klient może być dużo bardziej zainteresowany tym, ile pieniędzy jest na jego koncie i jakie są zyski z odsetek, niż funkcjami, które pozwalają na wpła- canie i wypłacanie pieniędzy. Klient postrzega rachunek jako bezpieczne miejsce dla swoich ciężko zarobionych pieniędzy. Nie obchodzi go, jak dokonywane są wypłaty lub wpłaty. Jedyne, czego potrzebuje, to prosty sposób na dokonywanie tych żmudnych operacji. Ale programista skoncentrował się na pisaniu tych właśnie nieciekawych fragmentów kodu w postaci funkcji /CMG GRQUKV i innych funkcji, a do zarządzania danymi utworzył skromne struktury. Mówiąc inaczej, skupił uwagę na tych elementach, które mało klienta obchodzą. Co więcej, nie istnieje specjalny związek między klientem a jego rachunkami bankowymi. Klient jest traktowany jak seria liter i cyfr, a operacje na danych odbywają się bez uwzględniania informacji o właścicielu konta i o stanie rachunku. Dla funkcji rachunek bankowy to po prostu numer — numer konta. m 1 Składnia nie jest w tym momencie istotna. Ważne, aby podkreślić użycie procedur i argumentów. Każdy język posiada własną składnię do ich definiowania. 26 Część I ♦ Pojęcia, techniki i aplikacje Bezpieczeństwo konta bankowego Następnie możemy zauważyć, że dowolny inny program lub programista może utwo- rzyć rachunek i dokonywać na nim operacji. Ponieważ rachunek jest przechowywany jako fragment danych, każdy, kto uzyska dostęp do rekordu z kontem, może zmienić jego wartość — nawet nielegalnie — i wypłacić pieniądze. Jest to konsekwencją faktu, że rachunek reprezentowany jest jako ciąg liter i cyfr. Nie istnieje zabezpieczenie róż- nych wartości w nim przechowywanych. Nie istnieje reguła, która określa, że rachunek może zostać zmieniony tylko przez zaufanego pracownika banku — a nawet jeśli ist- nieje, kto wymusi jej stosowanie? Języki takie, jak C lub Pascal, nie mogą tego zrobić, ponieważ nie widzą różnicy między rachunkiem bankowym a zwykłą liczbą całkowitą. Jeśli program ma wyświetlać dane z rachunku klientowi, dodawana jest nowa funkcja: 2TKPV#EEQWPV #EEQWPVVJKU#EEQWPV  Funkcja ta wyświetli dane rachunku. Ale powinna ona mieć informacje o tym, jakiego rodzaju jest to rachunek — oszczędnościowy, bieżący czy inny. To proste — wystar- czy sprawdzić wartość pola CEEQWPV6[RG. Niech w banku istnieją wymienione wcze- śniej trzy rodzaje kont — bieżące, oszczędnościowe i kredytowe. Funkcja 2TKPV#EEQ WPV zna te typy, ponieważ zostały na sztywno umieszczone w jej kodzie. Jak dotąd wszystko idzie dobrze. Teraz załóżmy, że dodawany jest nowy typ konta — konto emerytalne TGVKTGOGPVACEEQWPV. Co się stanie, jeśli przekażemy do funkcji 2TKPV#E EQWPV rachunek typu „konto emerytalne”? Funkcja nie zadziała. Możemy zobaczyć komunikat o błędzie: 0KGPCP[V[RTCEJWPMWY[ħYKGVNGPKGPKGOQľNKYG Albo nawet gorzej: 0KGRQRTCYP[V[RTCEJWPMWUMQPVCMVWLUKúCFOKPKUVTCVQTGO Dzieje się tak, ponieważ typ rachunku jest informacją na sztywno umieszczoną w sys- temie i nie może zostać zmieniony, dopóki nie zmieni się kod źródłowy, a program nie zostanie ponownie skompilowany i skonsolidowany. Jeśli więc dodamy nowy typ ra- chunku, trzeba zmienić wszystkie funkcje, w których występuje ta informacja, i przejść przez etap kompiluj-konsoliduj-testuj. Proces ten jest żmudny i narażony na błędy. Jak więc można sobie poradzić z tym problemem? Odpowiedź znów wynika z faktu, że funkcje i struktury danych traktowane są jako dwa odrębne byty, które nie mają ze sobą nic wspólnego. Z tego powodu zmiany w strukturze danych nie są łatwo rozumiane przez funkcje. Pożądaną sytuacją jest istnienie systemu, w którym dodanie nowego typu rachunku nie wpływa na inne typy i nie powoduje potrzeby globalnej rekompilacji kodu. Rozszerzanie istniejącej już implementacji jest bardzo kłopotliwe. O wszystkie te problemy można obwiniać złe rozłożenie akcentów w pierwotnym roz- wiązaniu. Programista jest w nim skoncentrowany bardziej na funkcjach, o których błęd- nie myśli, że są najważniejsze. Z kolei prawie zupełnie lekceważone są struktury danych, czyli elementy najbardziej istotne dla klienta. Mówiąc inaczej, główny nacisk kładzie się na to, jak coś zrobić, podczas gdy trzeba skupić się na tym, co robić. To właśnie miejsce, w którym programowanie obiektowe różni się od proceduralnego. Rozdział 1. ♦ Czym jest programowanie obiektowe? 27 Rozwiązywanie problemów w programowaniu obiektowym Jeśli rozwiązujemy problem rachunku bankowego za pomocą technik programowania obiektowego, trzeba zająć się głównie samym rachunkiem. Na pierwszym miejscu pro- gramista skupia się na tym, czego oczekuje klient, co jest dla niego ważne. W pro- gramowaniu obiektowym najważniejsze są dane, na których operujemy, a nie procedury, które implementują te operacje. Programista stara się zrozumieć, co użyt- kownik chciałby robić z danymi, a następnie implementuje te istotne operacje. Dodat- kowo dane i operacje nie są traktowane jako odrębne elementy, jak miało to miejsce wcześniej. Postrzegane są jako integralna całość. Dane udostępniane są wraz z zesta- wem operacji, które pozwalają użytkownikowi pracować z nimi. Jednocześnie dane same w sobie nie są dostępne dla żadnego zewnętrznego programu lub procedury. Jedynym sposobem ich zmiany jest korzystanie z operacji dostarczonych specjalnie dla tego celu. Możliwe operacje na rachunku dokonywane są w imieniu użytkownika. Można teraz powiedzieć, że rachunek bankowy jest klasą i da się utworzyć wiele jego egzemplarzy, a każdy z nich będzie obiektem. Dlatego programowanie obiektowe jest metodą pro- gramowania, w której programy składają się ze współpracujących ze sobą obiek- tów będących egzemplarzami klas. Klasy najczęściej związane są ze sobą poprzez dziedziczenie2. Kluczowe są tu pojęcia klasa i obiekt. Klasa to byt, który zbiera wspólne właściwości grupy obiektów. Obiekt to egzemplarz klasy. Wszystkie obiekty jednej klasy posiadają tę samą strukturę i funkcje zgodne z deklaracją tej klasy. Można patrzeć na klasę jak na foremkę do ciastek — wówczas ciasteczka byłyby egzemplarzami tworzonymi za jej pomocą. Analogia ta jest bardzo zgrubna, ale przypomina proces tworzenia obiektów na podstawie klasy. Foremka określa rozmiar i kształt ciastka — choć już nie jego smak. Podobnie klasa określa rozmiar i funkcje obiektów. W prawdziwym obiektowym roz- wiązaniu problemu wszystkie elementy są obiektami utworzonymi na podstawie klasy3. W programowaniu obiektowym myślimy w kategoriach klas, obiektów i relacji między nimi4. Shlaer i Mellor opisują różnice między programowaniem proceduralnym i obiek- towym. Analiza funkcjonalna odnosi się do trzech elementów projektowania syste- mu, w kolejności: algorytmy, przepływ danych, opis danych. Programowanie obiek- towe odwraca tę kolejność. Wracamy do problemu rachunku bankowego. Teraz w centrum zainteresowania jest rachunek bankowy, który staje się klasą. Poniżej znajduje się szkielet klasy $CPM#EEQWPV w języku C++. Podobnie jak w poprzednim przypadku, nie przejmuj się składnią. ENCUU$CPM#EEQWPV] RWDNKE Wiele szczegółów pominięto dla czytelności m 2 Pełny opis dziedziczenia znajduje się w dalszych rozdziałach. 3 Sytuacja taka prawie zachodzi w języku C++, jeśli założymy, że funkcja OCKP jest głównym obiektem, od którego wszystko się zaczyna. 4 Istnieją stosunkowo nieznane języki delegowania (ang. delegation languages), w których obiekty mogą tworzyć inne klasy. 28 Część I ♦ Pojęcia, techniki i aplikacje XQKF/CMG GRQUKV HNQCVCOQWPV  HNQCV9KVJ TCY  DQQN6TCPUHGT $CPM#EEQWPVVQHNQCVCOQWPV  HNQCV)GV$CNCPEG EQPUV RTKXCVG Implementacja danych do użytku w obrębie klasy BankAccount HNQCVDCNCPEG HNQCVKPVGTGUV;6  EJCT QYPGT KPVCEEQWPVAPWODGT _ Dla klienta istotna jest część publiczna — zawiera ona możliwe do wykonania operacje na klasie. Na rysunku 1.1 zaznaczono je pogrubioną czcionką. Deklaracje w regionie prywatnym nie są dostępne dla klienta. Są one przeznaczone do wyłącznego wewnętrz- nego użytku operacji. Na przykład operacja /CMG GRQUKV może być zaimplementowana w podany sposób: Implementacja operacji klasy BankAccount XQKF$CPM#EEQWPV/CMG GRQUKV HNQCVCOQWPV ] KH COQWPV  DCNCPEGDCNCPEG COQWPV _ Rysunek 1.1. Podział klasy na interfejs i implementację Dostęp do prywatnej składowej DCNCPEG i innych składowych prywatnych istnieje wy- łącznie z poziomu operacji zadeklarowanych w klasie $CPM#EEQWPV. Składowe te nie są dostępne do normalnego użytku z zewnątrz klasy. Takie prywatne dane określamy jako dane ukryte. Ten sposób ukrywania danych wewnątrz klasy nazywany jest hermetyza- cją danych. Więcej szczegółów na temat tego zagadnienia znajdziesz w rozdziale 2. Wprowadzenie do modelu obiektowego Jedną z przeszkód w zrozumieniu paradygmatu programowania obiektowego jest brak zrozumienia pojęć klasa i obiekt. Aby skutecznie programować w paradygmacie obiek- towym, należy dogłębnie zapoznać się z tymi pojęciami. Podstawowym bytem w programowaniu obiektowym jest klasa. Wróćmy do przykładu rachunku bankowego — każdy obiekt typu $CPM#EEQWPV posiada tę samą strukturę Rozdział 1. ♦ Czym jest programowanie obiektowe? 29 i funkcje. Dlatego na wszystkich obiektach $CPM#EEQWPV można wykonać operację /CMG GRQUKV i inne operacje tej klasy. Wszystkie obiekty posiadają też własny zestaw prywat- nych danych (DCNCPEG, CEEQWPVAPWODGT itd.), różnią się natomiast wartościami, które są w nich przechowywane. Na przykład obiekt CNRJC typu $CPM#EEQWPV może posiadać war- tość  w polu DCNCPEG, a obiekt DGVC może w tym samym polu posiadać wartość . Zostało to pokazane na rysunku 1.2. Rysunek 1.2. Przykładowe obiekty klasy BankAccount Obiekty są egzemplarzami („ciasteczkami”) klasy. Klasa widoczna jest tylko w kodzie źródłowym programu, podczas gdy obiekty uczestniczą w działaniu programu. To one zajmują miejsce w pamięci komputera. Można „dotknąć” i „poczuć” obiekt. Proces two- rzenia obiektu jest także nazywany konkretyzacją. W programowaniu proceduralnym zawsze mówi się o wywoływaniu procedur. Uży- wane są wyrażenia typu „wywoływanie procedury X” czy „wywoływanie Y”, gdzie X i Y to nazwy procedur. W programowaniu obiektowym nigdy nie mówimy: „Wywołaj X i wywołaj Y”. Zamiast tego używamy wyrażeń „Wykonaj X dla pewnego obiektu”. Jeśli istnieje obiekt O[#EEQWPV klasy $CPM#EEQWPV, można powiedzieć: „Wykonaj pro- cedurę /CMG GRQUKV dla obiektu O[#EEQWPV”. Procedury są wykonywane (wywoływane) dla obiektów. Bez obiektu po prostu nie możemy wywołać procedury. Nigdy nie
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Język C++. Efektywne programowanie obiektowe
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ą: