C++ Zaawansowane programowanie.pdf
(
395 KB
)
Pobierz
C++. Zaawansowane programowanie
IDZ DO
PRZYK£ADOW
Y ROZDZIA£
C++. Zaawansowane
SPIS TREŒCI
programowanie
KATALOG KSI¥¯EK
Autorzy: Nicholas A. Solter, Scott J. Kleper
T³umaczenie: Pawe³ Gonera, Rafa³ Joñca, Tomasz ¯mijewski
ISBN: 83-7361-998-4
Tytu³ orygina³
u:
Professional C++
Format: B5, stron: 912
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
Poznaj mo¿liwoœci i mechanizmy C++ stosowane przez profesjonalistów
• Efektywne zarz¹dzanie pamiêci¹
• Obs³uga b³êdów
• Biblioteki i wzorce projektowe
Jêzyk C++ od dawna cieszy siê zas³u¿on¹ popularnoœci¹ wœród twórców
oprogramowania. Jednak czêsto nawet najbardziej doœwiadczeni programiœci nie
wykorzystuj¹ wszystkich jego mo¿liwoœci. W opracowaniach dotycz¹cych tego jêzyka
najczêœciej omawiana jest sk³adnia i elementy jêzyka, a znacznie rzadziej — jego
praktyczne zastosowania. Brak odniesieñ do praktyki powoduje nieznajomoœæ wielu
niezwykle przydatnych i u³atwiaj¹cych pracê aspektów C++ i nadmierne
eksploatowanie prostych, ksi¹¿kowych konstrukcji.
Ksi¹¿ka „C++. Zaawansowane programowanie” to przegl¹d metod programowania nie
omawianych w wiêkszoœci publikacji. Ten przeznaczony dla œrednio zaawansowanych
programistów podrêcznik przedstawia zasady stosowania C++ do rozwi¹zywania
prawdziwych problemów. Opisuje nieznane mo¿liwoœci znacznie przyspieszaj¹ce
i usprawniaj¹ce pracê, sposoby tworzenia przenoœnego kodu oraz testowania
oprogramowania. Ksi¹¿ka zawiera równie¿ omówienie biblioteki standardowej C++
oraz wzorców projektowych.
• Zasady tworzenia projektów w C++
• Projektowanie obiektowe
• Korzystanie z biblioteki standardowej C++
• Tworzenie kodu przeznaczonego do wielokrotnego zastosowania
• Styl kodowania
• Zarz¹dzanie pamiêci¹
• Procedury obs³ugi wyj¹tków
• Przeci¹¿anie operatorów
• Tworzenie aplikacji wieloplatformowych
• Testowanie kodu i usuwanie b³êdów
• Programowanie rozproszone
• Stosowanie wzorców projektowych
Naucz siê korzystaæ z C++ tak, jak robi¹ to profesjonaliœci
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ONOWOŒCIACH
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
Spis treści
O autorach ................................................................................................................................................ 17
Wprowadzenie ......................................................................................................................................... 19
Część I Wprowadzenie do profesjonalnego C++ ............................................................. 23
Rozdział 1. Skrócony kurs C++ ...............................................................................................................25
Podstawy C++ ............................................................................................................. 25
Teraz obowiązkowo Hello, World .............................................................................. 26
Przestrzenie nazw ................................................................................................... 28
Zmienne ................................................................................................................ 30
Operatory ............................................................................................................... 32
Typy danych ........................................................................................................... 34
Wyrażenia warunkowe ............................................................................................. 36
Pętle ...................................................................................................................... 38
Tablice ................................................................................................................... 40
Funkcje .................................................................................................................. 41
To był elementarz ................................................................................................... 42
C++ z bliska ................................................................................................................ 42
Wskaźniki i pamięć alokowana dynamicznie .............................................................. 42
Łańcuchy znakowe w C++ ........................................................................................ 45
Referencje ............................................................................................................. 47
Wyjątki ................................................................................................................... 48
Wiele zastosowań słowa kluczowego const ............................................................... 49
C++ jako język obiektowy .............................................................................................. 50
Deklarowanie klasy ................................................................................................. 51
Nasz pierwszy praktyczny program C++ .......................................................................... 53
System obsługi kadrowej ......................................................................................... 53
Klasa Employee ...................................................................................................... 54
Klasa Database ...................................................................................................... 58
Interfejs użytkownika ............................................................................................... 62
Udoskonalanie programu ......................................................................................... 65
Podsumowanie ............................................................................................................ 65
Rozdział 2. Tworzenie profesjonalnych programów w C++ ................................................................67
Czym jest projekt programu? ......................................................................................... 68
Dlaczego projekt programu jest tak ważny? .................................................................... 68
Co jest szczególnego w projektach C++? ....................................................................... 70
Dwie zasady tworzenia projektów w C++ ........................................................................ 71
Abstrakcja .............................................................................................................. 71
Wielokrotne użycie .................................................................................................. 73
6
C++. Zaawansowane programowanie
Projektowanie programu szachowego ............................................................................. 75
Wymagania ............................................................................................................ 75
Kolejne etapy projektowania .................................................................................... 76
Podsumowanie ............................................................................................................ 80
Rozdział 3. Projektowanie obiektowe ....................................................................................................83
Obiektowe spojrzenie na świat ...................................................................................... 83
Czy myślę proceduralnie? ........................................................................................ 83
Filozofia obiektowa ................................................................................................. 84
W świecie obiektów ................................................................................................ 87
Powiązania obiektów ............................................................................................... 89
Abstrakcja .............................................................................................................. 99
Podsumowanie .......................................................................................................... 102
Rozdział 4. Użycie bibliotek i wzorców ................................................................................................ 103
Wielokrotne użycie kodu ............................................................................................. 103
Uwaga na temat terminologii ................................................................................. 104
Podejmowanie decyzji, czy ponownie wykorzystać kod .............................................. 105
Strategie wielokrotnego użycia kodu ....................................................................... 107
Korzystanie z obcych aplikacji ................................................................................ 112
Biblioteki open-source ........................................................................................... 113
Standardowa biblioteka C++ .................................................................................. 114
Projektowanie z użyciem wzorców i technik ................................................................... 127
Techniki projektowe .............................................................................................. 128
Wzorce projektowe ................................................................................................ 129
Podsumowanie .......................................................................................................... 130
Rozdział 5. Projektowanie z myślą o ponownym użyciu ...................................................................... 131
Filozofia wielokrotnego użycia ..................................................................................... 132
Jak projektować kod wielokrotnego użycia .................................................................... 132
Użycie abstrakcji ................................................................................................... 133
Struktura kodu wielokrotnego użycia ....................................................................... 134
Projektowanie interfejsów ...................................................................................... 139
Łączenie ogólności i prostoty użycia ....................................................................... 145
Podsumowanie .......................................................................................................... 146
Rozdział 6. Użycie metod inżynierii oprogramowania ........................................................................ 147
Potrzeba stosowania procesu ..................................................................................... 147
Modele cyklu życia oprogramowania ............................................................................ 149
Model etapowy i kaskadowy .................................................................................. 149
Metoda spirali ...................................................................................................... 152
Rational Unified Process ....................................................................................... 154
Metodyki inżynierii oprogramowania ............................................................................. 155
Programowanie ekstremalne (XP) ........................................................................... 156
Sąd nad oprogramowaniem ................................................................................... 160
Tworzenie własnego procesu i metodyki ....................................................................... 161
Bądź otwarty na nowe pomysły .............................................................................. 161
Dziel się pomysłami .............................................................................................. 161
Zorientuj się, co działa, a co nie ............................................................................ 162
Nie bądź renegatem .............................................................................................. 162
Podsumowanie .......................................................................................................... 162
Spis treści
7
Część II Profesjonalne kodowanie w C++ .......................................................................163
Rozdział 7. Styl kodowania .................................................................................................................... 165
Piękny wygląd ............................................................................................................ 165
Myślenie o przyszłości ........................................................................................... 165
Zachowanie porządku ............................................................................................ 166
Elementy dobrego stylu ......................................................................................... 166
Dokumentowanie kodu ............................................................................................... 166
Po co pisać komentarze ........................................................................................ 166
Style komentowania .............................................................................................. 169
Komentarze w tej książce ...................................................................................... 174
Dekompozycja ........................................................................................................... 174
Dekompozycja przez refaktoring ............................................................................. 174
Dekompozycja na etapie projektu ........................................................................... 176
Dekompozycja w tej książce ................................................................................... 176
Nazewnictwo ............................................................................................................. 176
Dobór właściwej nazwy .......................................................................................... 177
Konwencje nazewnicze .......................................................................................... 177
Elementy języka a styl ................................................................................................ 180
Stałe ................................................................................................................... 180
Korzystanie ze zmiennych const ............................................................................. 180
Użycie referencji zamiast wskaźników ..................................................................... 180
Wyjątki użytkownika .............................................................................................. 181
Formatowanie ............................................................................................................ 181
Rozmieszczenie nawiasów klamrowych ................................................................... 182
Spacje i nawiasy ................................................................................................... 183
Spacje i tabulatory ................................................................................................ 183
Wyzwania związane ze stylem ..................................................................................... 183
Podsumowanie .......................................................................................................... 184
Rozdział 8. Poznajemy lepiej klasy i obiekty ........................................................................................ 185
Wprowadzenie do przykładu arkusza kalkulacyjnego .......................................................... 185
Pisanie klas .............................................................................................................. 186
Definicje klasy ...................................................................................................... 186
Definiowanie metod .............................................................................................. 188
Użycie obiektów .................................................................................................... 192
Cykl życia obiektów .................................................................................................... 193
Tworzenie obiektu ................................................................................................. 193
Usuwanie obiektu ................................................................................................. 204
Przypisania do obiektów ........................................................................................ 206
Odróżnianie kopiowania od przypisania ................................................................... 208
Podsumowanie .......................................................................................................... 210
Rozdział 9. Doskonalenie znajomości klas i obiektów .......................................................................... 211
Dynamiczna alokacja pamięci w obiektach ................................................................... 211
Klasa Spreadsheet ............................................................................................... 212
Zwalnianie pamięci w destruktorach ....................................................................... 213
Obsługa kopiowania i przypisania ........................................................................... 214
Różne rodzaje pól w klasach ....................................................................................... 221
Pola statyczne ...................................................................................................... 221
Pola stałe ............................................................................................................ 223
8
C++. Zaawansowane programowanie
Pola będące referencjami ...................................................................................... 225
Pola będące stałymi referencjami ........................................................................... 226
Jeszcze o metodach ................................................................................................... 226
Metody statyczne .................................................................................................. 226
Metody stałe ........................................................................................................ 227
Przeciążanie metod ............................................................................................... 229
Parametry domyślne ............................................................................................. 230
Metody inline ....................................................................................................... 231
Klasy zagnieżdżone .................................................................................................... 233
Zaprzyjaźnienie .......................................................................................................... 235
Przeciążanie operatorów ............................................................................................. 236
Implementacja dodawania ..................................................................................... 236
Przeciążanie operatorów arytmetycznych ................................................................. 240
Przeciążanie operatorów porównania ...................................................................... 242
Tworzenie typów z przeciążaniem operatorów .......................................................... 244
Wskaźniki pól i metod ................................................................................................ 244
Tworzenie klas abstrakcyjnych .................................................................................... 245
Użycie klas interfejsu i implementacji ..................................................................... 246
Podsumowanie .......................................................................................................... 249
Rozdział 10. Przygoda z dziedziczeniem .............................................................................................. 251
Klasy i dziedziczenie .................................................................................................. 251
Rozszerzanie klas ................................................................................................. 252
Nadpisywanie metod ............................................................................................. 255
Dziedziczenie a wielokrotne użycie kodu ...................................................................... 258
Klasa WeatherPrediction ....................................................................................... 258
Nowe możliwości w podklasie ................................................................................ 259
Inne możliwości w podklasie .................................................................................. 261
Szacunek dla rodziców ............................................................................................... 262
Konstruktory rodziców ........................................................................................... 262
Destruktory rodziców ............................................................................................. 264
Odwołania do danych rodziców ............................................................................... 266
Rzutowanie w górę i w dół ..................................................................................... 267
Dziedziczenie i polimorfizm ......................................................................................... 268
Powrót do arkusza kalkulacyjnego .......................................................................... 269
Polimorficzna komórka arkusza .............................................................................. 269
Klasa bazowa komórki arkusza .............................................................................. 270
Poszczególne podklasy .......................................................................................... 272
Polimorfizm dla zaawansowanych ........................................................................... 274
Uwagi na przyszłość .............................................................................................. 275
Dziedziczenie wielokrotne ........................................................................................... 276
Dziedziczenie po wielu klasach .............................................................................. 277
Kolizje nazw i niejednoznaczne klasy bazowe .......................................................... 278
Ciekawostki i tajemnice dziedziczenia .......................................................................... 281
Zmiana charakterystyki nadpisanej metody ............................................................. 281
Przypadki szczególne nadpisywania metod .............................................................. 285
Konstruktory kopiujące i operator równości ............................................................. 291
Prawda o wirtualności ........................................................................................... 293
Typy podczas działania programu ........................................................................... 296
Dziedziczenie niepubliczne .................................................................................... 297
Wirtualne klasy bazowe ......................................................................................... 298
Podsumowanie .......................................................................................................... 299
Plik z chomika:
Ravel25
Inne pliki z tego folderu:
Asembler dla procesorow Intel Vademecum profesjonalisty.pdf
(400 KB)
Asembler cwiczenia praktyczne.pdf
(358 KB)
Architektura systemow zarzadzania przedsiebiorstwem Wzorce projektowe.pdf
(829 KB)
Architektura oprogramowania Metody oceny oraz analiza przypadkow.pdf
(429 KB)
Aplikacje w Visual C++ 2005 Przyklady.pdf
(296 KB)
Inne foldery tego chomika:
(X) HTML
algorytmy i struktury danych
asembler
C++
Core JAVA2 Podstawy
Zgłoś jeśli
naruszono regulamin