[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
C++. Projektowanie
SPIS TRECI
zorientowane obiektowo.
KATALOG KSI¥¯EK
Vademecum profesjonalisty
Autor: Nicolai M. Josuttis
T³umaczenie: Jaromir Senczyk
ISBN: 83-7361-195-9
Tytu³ orygina³
Format: B5, stron: 560
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
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³aciwoci jêzyka i wyjania 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ólnoci —
na przyk³ad implementacjê polimorfizmu. Nicolai Josuttis omawia mo¿liwoæ ³¹czenia
szablonów z programowaniem obiektowym, która decyduje o potê¿nych mo¿liwociach
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 wejcia-wyjcia
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.
Wyczerpuj¹cy, szczegó³owy, praktyczny i aktualny podrêcznik programowania w jêzyku C++.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
1.1. Dlaczego napisałem t ksik?......................................................................................13
1.2. Wymagania .....................................................................................................................14
1.3. Organizacja ksiki.........................................................................................................14
1.4. W jaki sposób naley czyta" ksik? ............................................................................15
1.5. Przykłady programów i dodatkowe informacje..............................................................15
!"#$
2.1. Jzyk C++ .......................................................................................................................19
2.1.1. Kryteria projektowania .........................................................................................19
2.1.2. Historia jzyka ......................................................................................................20
2.2. C++ jako jzyk programowania obiektowego................................................................20
2.2.1. Obiekty, klasy i instancje......................................................................................21
2.2.2. Klasy w jzyku C++ .............................................................................................23
2.2.3. Hermetyzacja danych............................................................................................25
2.2.4. Dziedziczenie........................................................................................................27
2.2.5. Polimorfizm ..........................................................................................................28
2.3. Inne koncepcje jzyka C++.............................................................................................29
2.3.1. Obsługa wyjtków ................................................................................................30
2.3.2. Szablony................................................................................................................30
2.3.3. Przestrzenie nazw..................................................................................................32
2.4. Terminologia...................................................................................................................32
# %
3.1. Pierwszy program ...........................................................................................................35
3.1.1. „Hello, World!”.....................................................................................................35
3.1.2. Komentarze w jzyku 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 sterujce.............................................................................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 sterujce ...............................................................................................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 zawierajcy definicj.....................................................................60
3.3.3. Plik ?ródłowy zawierajcy 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. ŁaBcuchy znaków ...........................................................................................................70
3.4.1. Pierwszy przykład programu wykorzystujcego łaBcuchy znaków .....................70
3.4.2. Kolejny przykładowy program wykorzystujcy łaBcuchy znaków......................74
3.4.3. Przegld operacji na łaBcuchach znaków .............................................................78
3.4.4. ŁaBcuchy znaków i C-łaBcuchy............................................................................79
3.4.5. Podsumowanie......................................................................................................80
3.5. Kolekcje..........................................................................................................................80
3.5.1. Program wykorzystujcy klas vector ..................................................................81
3.5.2. Program wykorzystujcy klas deque...................................................................82
3.5.3. Wektory i kolejki ..................................................................................................83
3.5.4. Iteratory.................................................................................................................84
3.5.5. Przykładowy program wykorzystujcy listy.........................................................87
3.5.6. Przykłady programów wykorzystujcych kontenery asocjacyjne........................88
3.5.7. Algorytmy.............................................................................................................92
3.5.8. Algorytmy wielozakresowe ..................................................................................96
3.5.9. Iteratory strumieni.................................................................................................98
3.5.10. Uwagi koBcowe ................................................................................................100
3.5.11. Podsumowanie..................................................................................................101
3.6. Obsługa wyjtków ........................................................................................................102
3.6.1. Powody wprowadzenia obsługi wyjtków..........................................................102
3.6.2. Koncepcja obsługi wyjtków..............................................................................104
3.6.3. Standardowe klasy wyjtków .............................................................................105
3.6.4. Przykład obsługi wyjtku....................................................................................106
3.6.5. Obsługa nieoczekiwanych wyjtkó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-łaBcuchy...................................................................................112
3.7.1. Wska?niki ...........................................................................................................112
3.7.2. Tablice.................................................................................................................115
3.7.3. C-łaBcuchy..........................................................................................................117
3.7.4. Podsumowanie....................................................................................................121
3.8. Zarzdzanie pamici za pomoc operatorów new i delete..........................................121
3.8.1. Operator new.......................................................................................................123
3.8.2. Operator delete....................................................................................................123
Spis treci
5
3.8.3. Dynamiczne zarzdzanie pamici tablic...........................................................124
3.8.4. Obsługa błdów zwizanych z operatorem new.................................................126
3.8.5. Podsumowanie....................................................................................................126
3.9. Komunikacja ze =wiatem zewntrznym .......................................................................126
3.9.1. Parametry wywołania programu.........................................................................126
3.9.2. Dostp 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
& !'
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. Przecienie 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. Wstpna 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 uytkownika .......................................................177
4.3.5. Instrukcja using...................................................................................................178
4.3.6. Deklaracje pomidzy instrukcjami .....................................................................179
4.3.7. Konstruktory kopiujce.......................................................................................181
4.3.8. Podsumowanie....................................................................................................182
4.4. Referencje i stałe...........................................................................................................183
4.4.1. Konstruktory kopiujce 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 wykorzystujca 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 uytkownika.......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 wyjtków w klasach .......................................................................................229
4.7.1. Powody zastosowania obsługi wyjtków w klasie Fraction...............................229
4.7.2. Obsługa wyjtków w klasie Fraction..................................................................230
4.7.3. Klasy wyjtków ..................................................................................................237
4.7.4. Ponowne wyrzucenie wyjtku ............................................................................237
4.7.5. Wyjtki w destruktorach.....................................................................................238
4.7.6. Wyjtki i deklaracje interfejsów.........................................................................238
4.7.7. Hierarchie klas wyjtków ...................................................................................239
4.7.8. Projektowanie klas wyjtków .............................................................................242
4.7.9. Wyrzucanie standardowych wyjtków ...............................................................244
4.7.10. BezpieczeBstwo wyjtków................................................................................244
4.7.11. Podsumowanie..................................................................................................245
% (')&*
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 wizanie funkcji...........................................................267
5.2.3. Przecienie i przesłanianie................................................................................271
5.2.4. Dostp 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 dostpu.....................................................281
5.2.9. Podsumowanie....................................................................................................284
[ Pobierz całość w formacie PDF ]