C_Programowanie_zorientowane_obiektowo_Vademecum_profesjonalisty_cpzobv.pdf

(608 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
C++. Projektowanie
zorientowane obiektowo.
Vademecum profesjonalisty
Autor: Nicolai M. Josuttis
T³umaczenie: Jaromir Senczyk
ISBN: 83-7361-195-9
Tytu³ orygina³u:
Object-Oriented Programming in C++
Format: B5, stron: 560
TWÓJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
ZAMÓW CENNIK
C++ jest obecnie wiod¹cym jêzykiem programowania obiektowego. Jego podstawowymi
zaletami w stosunku do innych jêzyków obiektowych jest wysoka efektywno æ
i uniwersalno æ. Stosowany jest do tworzenia komercyjnego oprogramowania oraz
efektywnych rozwi¹zañ z³o¿onych problemów.
Ksi¹¿ka krok po kroku omawia wszystkie w³a ciwo ci jêzyka i wyja nia sposoby ich
praktycznego u¿ycia. Przedstawione przyk³ady programów nie s¹ zbyt skomplikowane,
by nie odrywaæ Twojej uwagi od omawianych zagadnieñ, ale nie s¹ te¿ sztucznie
uproszczone. Kluczowym za³o¿eniem jêzyka C++ jest programowanie z wykorzystaniem
szablonów, które umo¿liwiaj¹ tworzenie rozwi¹zañ o wysokim poziomie ogólno ci —
na przyk³ad implementacjê polimorfizmu. Nicolai Josuttis omawia mo¿liwo æ ³¹czenia
szablonów z programowaniem obiektowym, która decyduje o potê¿nych mo¿liwo ciach
jêzyka C++ jako narzêdzia tworzenia wydajnych programów. W tym zakresie ksi¹¿ka
wykracza daleko poza podstawy.
• Wprowadzenie do C++ i programowania obiektowego
• Podstawowe pojêcia jêzyka C++
• Programowanie klas
• Dziedziczenie i polimorfizm
• Sk³adowe dynamiczne i statyczne
• Szablony jêzyka C++
• Szczegó³owe omówienie standardowej biblioteki wej cia-wyj cia
Ksi¹¿ka ta jest idealnym podrêcznikiem umo¿liwiaj¹cym studiowanie jêzyka C++
w domowym zaciszu. Prezentuje ona zagadnienia podstawowe, ale w wielu przypadkach
przekracza je dostarczaj¹c prawdziwie profesjonalnej wiedzy.
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Wyczerpuj¹cy, szczegó³owy, praktyczny i aktualny podrêcznik programowania w jêzyku C++.
5RKU VTG EK
2T\GFOQYC
4Q\F\KC
1 MUKæ EG
1.1. Dlaczego napisałem tę ksią kę?......................................................................................13
1.2. Wymagania .....................................................................................................................14
1.3. Organizacja ksią ki.........................................................................................................14
1.4. W jaki sposób nale y czytać ksią kę? ............................................................................15
1.5. Przykłady programów i dodatkowe informacje..............................................................15
4Q\F\KC
9RTQYCF\GPKG Lú\[M % K RTQITCOQYCPKG QDKGMVQYG
2.1. Język C++ .......................................................................................................................19
2.1.1. Kryteria projektowania .........................................................................................19
2.1.2. Historia języka ......................................................................................................20
2.2. C++ jako język programowania obiektowego ................................................................20
2.2.1. Obiekty, klasy i instancje......................................................................................21
2.2.2. Klasy w języku C++ .............................................................................................23
2.2.3. Hermetyzacja danych............................................................................................25
2.2.4. Dziedziczenie........................................................................................................27
2.2.5. Polimorfizm ..........................................................................................................28
2.3. Inne koncepcje języka C++.............................................................................................29
2.3.1. Obsługa wyjątków ................................................................................................30
2.3.2. Szablony................................................................................................................30
2.3.3. Przestrzenie nazw..................................................................................................32
2.4. Terminologia...................................................................................................................32
4Q\F\KC
2QFUVCYQYG RQLúEKC Lú\[MC %
3.1. Pierwszy program ...........................................................................................................35
3.1.1. „Hello, World!”.....................................................................................................35
3.1.2. Komentarze w języku C++ ...................................................................................37
3.1.3. Funkcja main() ......................................................................................................37
3.1.4. Wejście i wyjście ..................................................................................................39
3.1.5. Przestrzenie nazw..................................................................................................40
3.1.6. Podsumowanie ......................................................................................................41
3.2. Typy, operatory i instrukcje sterujące.............................................................................41
3.2.1. Pierwszy program, który przeprowadza obliczenia ..............................................41
3.2.2. Typy podstawowe .................................................................................................44
4
C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty
3.2.3. Operatory ..............................................................................................................48
3.2.4. Instrukcje sterujące ...............................................................................................54
3.2.5. Podsumowanie ......................................................................................................57
3.3. Funkcje i moduły ............................................................................................................58
3.3.1. Pliki nagłówkowe..................................................................................................58
3.3.2. Plik źródłowy zawierający definicję.....................................................................60
3.3.3. Plik źródłowy zawierający wywołanie funkcji .....................................................60
3.3.4. Kompilacja i konsolidacja.....................................................................................61
3.3.5. Rozszerzenia nazw plików....................................................................................62
3.3.6. Systemowe pliki nagłówkowe i biblioteki............................................................63
3.3.7. Preprocesor ...........................................................................................................63
3.3.8. Przestrzenie nazw..................................................................................................66
3.3.9. Słowo kluczowe static...........................................................................................67
3.3.10. Podsumowanie ....................................................................................................69
3.4. Łańcuchy znaków ...........................................................................................................70
3.4.1. Pierwszy przykład programu wykorzystującego łańcuchy znaków .....................70
3.4.2. Kolejny przykładowy program wykorzystujący łańcuchy znaków ......................74
3.4.3. Przegląd operacji na łańcuchach znaków .............................................................78
3.4.4. Łańcuchy znaków i C-łańcuchy............................................................................79
3.4.5. Podsumowanie ......................................................................................................80
3.5. Kolekcje ..........................................................................................................................80
3.5.1. Program wykorzystujący klasę vector ..................................................................81
3.5.2. Program wykorzystujący klasę deque...................................................................82
3.5.3. Wektory i kolejki ..................................................................................................83
3.5.4. Iteratory.................................................................................................................84
3.5.5. Przykładowy program wykorzystujący listy.........................................................87
3.5.6. Przykłady programów wykorzystujących kontenery asocjacyjne ........................88
3.5.7. Algorytmy .............................................................................................................92
3.5.8. Algorytmy wielozakresowe ..................................................................................96
3.5.9. Iteratory strumieni.................................................................................................98
3.5.10. Uwagi końcowe ................................................................................................100
3.5.11. Podsumowanie ..................................................................................................101
3.6. Obsługa wyjątków ........................................................................................................102
3.6.1. Powody wprowadzenia obsługi wyjątków..........................................................102
3.6.2. Koncepcja obsługi wyjątków..............................................................................104
3.6.3. Standardowe klasy wyjątków .............................................................................105
3.6.4. Przykład obsługi wyjątku....................................................................................106
3.6.5. Obsługa nieoczekiwanych wyjątków..................................................................109
3.6.6. Funkcje pomocnicze obsługi błędów..................................................................110
3.6.7. Podsumowanie ....................................................................................................111
3.7. Wskaźniki, tablice i C-łańcuchy ...................................................................................112
3.7.1. Wskaźniki ...........................................................................................................112
3.7.2. Tablice.................................................................................................................115
3.7.3. C-łańcuchy ..........................................................................................................117
3.7.4. Podsumowanie ....................................................................................................121
3.8. Zarządzanie pamięcią za pomocą operatorów new i delete..........................................121
3.8.1. Operator new.......................................................................................................123
3.8.2. Operator delete....................................................................................................123
Spis treści
5
3.8.3. Dynamiczne zarządzanie pamięcią tablic ...........................................................124
3.8.4. Obsługa błędów związanych z operatorem new.................................................126
3.8.5. Podsumowanie ....................................................................................................126
3.9. Komunikacja ze światem zewnętrznym .......................................................................126
3.9.1. Parametry wywołania programu .........................................................................126
3.9.2. Dostęp do zmiennych środowiska ......................................................................128
3.9.3. Przerwanie działania programu...........................................................................128
3.9.4. Wywoływanie innych programów......................................................................129
3.9.5. Podsumowanie ....................................................................................................130
4Q\F\KC
2TQITCOQYCPKG MNCU
4.1. Pierwsza klasa: Fraction ...............................................................................................131
4.1.1. Zanim rozpoczniemy implementację..................................................................131
4.1.2. Deklaracja klasy Fraction ...................................................................................134
4.1.3. Struktura klasy ....................................................................................................135
4.1.4. Funkcje składowe................................................................................................138
4.1.5. Konstruktory .......................................................................................................138
4.1.6. Przecią enie funkcji ............................................................................................140
4.1.7. Implementacja klasy Fraction .............................................................................141
4.1.8. Wykorzystanie klasy Fraction.............................................................................146
4.1.9. Tworzenie obiektów tymczasowych...................................................................151
4.1.10. Notacja UML ....................................................................................................152
4.1.11. Podsumowanie ..................................................................................................152
4.2. Operatory klas...............................................................................................................153
4.2.1. Deklaracje operatorów ........................................................................................153
4.2.2. Implementacja operatorów..................................................................................156
4.2.3. Posługiwanie się operatorami .............................................................................163
4.2.4. Operatory globalne..............................................................................................164
4.2.5. Ograniczenia w definiowaniu operatorów ..........................................................165
4.2.6. Specjalne właściwości niektórych operatorów ...................................................166
4.2.7. Podsumowanie ....................................................................................................170
4.3. Optymalizacja efektywności kodu................................................................................170
4.3.1. Wstępna optymalizacja klasy Fraction ...............................................................171
4.3.2. Domyślne parametry funkcji...............................................................................174
4.3.3. Funkcje rozwijane w miejscu wywołania ...........................................................175
4.3.4. Optymalizacja z perspektywy u ytkownika .......................................................177
4.3.5. Instrukcja using...................................................................................................178
4.3.6. Deklaracje pomiędzy instrukcjami .....................................................................179
4.3.7. Konstruktory kopiujące.......................................................................................181
4.3.8. Podsumowanie ....................................................................................................182
4.4. Referencje i stałe...........................................................................................................183
4.4.1. Konstruktory kopiujące i przekazywanie parametrów .......................................183
4.4.2. Referencje ...........................................................................................................184
4.4.3. Stałe.....................................................................................................................187
4.4.4. Stałe funkcje składowe .......................................................................................189
4.4.5. Klasa Fraction wykorzystująca referencje ..........................................................190
4.4.6. Wskaźniki stałych i stałe wskaźniki ...................................................................193
4.4.7. Podsumowanie ....................................................................................................195
6
C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty
4.5. Strumienie wejścia i wyjścia.........................................................................................196
4.5.1. Strumienie ...........................................................................................................196
4.5.2. Korzystanie ze strumieni.....................................................................................197
4.5.3. Stan strumienia....................................................................................................203
4.5.4. Operatory wejścia i wyjścia dla typów definiowanych przez u ytkownika .......205
4.5.5. Podsumowanie ....................................................................................................214
4.6. Klasy zaprzyjaźnione i inne typy..................................................................................214
4.6.1. Automatyczna konwersja typów.........................................................................215
4.6.2. Słowo kluczowe explicit .....................................................................................217
4.6.3. Funkcje zaprzyjaźnione ......................................................................................217
4.6.4. Funkcje konwersji...............................................................................................223
4.6.5. Problemy automatycznej konwersji typu............................................................225
4.6.6. Inne zastosowania słowa kluczowego friend......................................................227
4.6.7. Słowo kluczowe friend i programowanie obiektowe..........................................227
4.6.8. Podsumowanie ....................................................................................................228
4.7. Obsługa wyjątków w klasach .......................................................................................229
4.7.1. Powody zastosowania obsługi wyjątków w klasie Fraction ...............................229
4.7.2. Obsługa wyjątków w klasie Fraction..................................................................230
4.7.3. Klasy wyjątków ..................................................................................................237
4.7.4. Ponowne wyrzucenie wyjątku ............................................................................237
4.7.5. Wyjątki w destruktorach .....................................................................................238
4.7.6. Wyjątki i deklaracje interfejsów .........................................................................238
4.7.7. Hierarchie klas wyjątków ...................................................................................239
4.7.8. Projektowanie klas wyjątków .............................................................................242
4.7.9. Wyrzucanie standardowych wyjątków ...............................................................244
4.7.10. Bezpieczeństwo wyjątków................................................................................244
4.7.11. Podsumowanie ..................................................................................................245
4Q\F\KC
&\KGF\KE\GPKG K RQNKOQTHK\O
5.1. Dziedziczenie pojedyncze.............................................................................................249
5.1.1. Klasa Fraction jako klasa bazowa.......................................................................249
5.1.2. Klasa pochodna RFraction..................................................................................251
5.1.3. Deklaracja klasy pochodnej RFraction ...............................................................253
5.1.4. Dziedziczenie i konstruktory ..............................................................................255
5.1.5. Implementacja klas pochodnych.........................................................................258
5.1.6. Wykorzystanie klasy pochodnej .........................................................................260
5.1.7. Konstruktory obiektów klasy bazowej................................................................262
5.1.8. Podsumowanie ....................................................................................................264
5.2. Funkcje wirtualne .........................................................................................................264
5.2.1. Problemy z przesłanianiem funkcji.....................................................................265
5.2.2. Statyczne i dynamiczne wiązanie funkcji ...........................................................267
5.2.3. Przecią enie i przesłanianie ................................................................................271
5.2.4. Dostęp do parametrów klasy bazowej ................................................................273
5.2.5. Destruktory wirtualne .........................................................................................274
5.2.6. Właściwe sposoby stosowania dziedziczenia .....................................................275
5.2.7. Inne pułapki przesłaniania funkcji ......................................................................279
5.2.8. Dziedziczenie prywatne i deklaracje dostępu .....................................................281
5.2.9. Podsumowanie ....................................................................................................284

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin